dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 441
 442 #include <dali/devel-api/images/nine-patch-image.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457
 458 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 459 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 460 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 461
 462 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 464 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 465
 466 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 467 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 #include <dali/public-api/events/mouse-button.h>
 475
 476 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 477
 478
 479 // add here SWIG version check
 480
 481 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 482 // disable Swig-dependent warnings
 483
 484 // 'identifier1' has C-linkage specified,
 485 // but returns UDT 'identifier2' which is incompatible with C
 486 #pragma warning(disable: 4190)
 487
 488 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 489 #pragma warning(disable: 4800)
 490
 491 // debug info too long etc etc
 492 #pragma warning(disable: 4786)
 493 #endif
 494
 495
 496 #include <stdexcept>
 497
 498
 499 #include <string>
 500
 501
 502 #include <vector>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <map>
 508 #include <algorithm>
 509 #include <stdexcept>
 510
 511
 512 #include <utility>
 513
 514
 515 typedef float floatp;
 516
 517 SWIGINTERN floatp *new_floatp(){
 518   return new float();
 519 }
 520 SWIGINTERN void delete_floatp(floatp *self){
 521   if (self) delete self;
 522 }
 523 SWIGINTERN void floatp_assign(floatp *self,float value){
 524   *self = value;
 525 }
 526 SWIGINTERN float floatp_value(floatp *self){
 527   return *self;
 528 }
 529 SWIGINTERN float *floatp_cast(floatp *self){
 530   return self;
 531 }
 532 SWIGINTERN floatp *floatp_frompointer(float *t){
 533   return (floatp *) t;
 534 }
 535
 536 typedef int intp;
 537
 538 SWIGINTERN intp *new_intp(){
 539   return new int();
 540 }
 541 SWIGINTERN void delete_intp(intp *self){
 542   if (self) delete self;
 543 }
 544 SWIGINTERN void intp_assign(intp *self,int value){
 545   *self = value;
 546 }
 547 SWIGINTERN int intp_value(intp *self){
 548   return *self;
 549 }
 550 SWIGINTERN int *intp_cast(intp *self){
 551   return self;
 552 }
 553 SWIGINTERN intp *intp_frompointer(int *t){
 554   return (intp *) t;
 555 }
 556
 557 typedef double doublep;
 558
 559 SWIGINTERN doublep *new_doublep(){
 560   return new double();
 561 }
 562 SWIGINTERN void delete_doublep(doublep *self){
 563   if (self) delete self;
 564 }
 565 SWIGINTERN void doublep_assign(doublep *self,double value){
 566   *self = value;
 567 }
 568 SWIGINTERN double doublep_value(doublep *self){
 569   return *self;
 570 }
 571 SWIGINTERN double *doublep_cast(doublep *self){
 572   return self;
 573 }
 574 SWIGINTERN doublep *doublep_frompointer(double *t){
 575   return (doublep *) t;
 576 }
 577
 578 typedef unsigned int uintp;
 579
 580 SWIGINTERN uintp *new_uintp(){
 581   return new unsigned int();
 582 }
 583 SWIGINTERN void delete_uintp(uintp *self){
 584   if (self) delete self;
 585 }
 586 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 587   *self = value;
 588 }
 589 SWIGINTERN unsigned int uintp_value(uintp *self){
 590   return *self;
 591 }
 592 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 593   return self;
 594 }
 595 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 596   return (uintp *) t;
 597 }
 598
 599 typedef unsigned short ushortp;
 600
 601 SWIGINTERN ushortp *new_ushortp(){
 602   return new unsigned short();
 603 }
 604 SWIGINTERN void delete_ushortp(ushortp *self){
 605   if (self) delete self;
 606 }
 607 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 608   *self = value;
 609 }
 610 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 611   return *self;
 612 }
 613 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 614   return self;
 615 }
 616 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 617   return (ushortp *) t;
 618 }
 619
 620 unsigned int int_to_uint(int x) {
 621    return (unsigned int) x;
 622 }
 623
 624
 625 using namespace Dali;
 626 using namespace Dali::Toolkit;
 627
 628 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 629 {
 630   bool result = false;
 631   try
 632   {
 633     // C++ code. DALi uses Handle <-> Body design pattern.
 634     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 635     // Handles in DALi can be converted into a boolean type
 636     // to check if the handle has a valid body attached to it.
 637     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 638     if( *self )
 639     {
 640       result = true;
 641     }
 642     else
 643     {
 644       result = false;
 645     }
 646   }
 647   catch (std::out_of_range& e)
 648   {
 649     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 650     return 0;
 651   }
 652   catch (std::exception& e)
 653   {
 654     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 655     return 0;
 656   }
 657   catch (DaliException e)
 658   {
 659     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 660     return 0;
 661   }
 662   catch (...)
 663   {
 664     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 665     return 0;
 666   }
 667   return result;
 668 }
 669
 670 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 671 {
 672   bool result = false;
 673   try
 674   {
 675     // C++ code. Check if two handles reference the same implemtion
 676     if( *self == rhs)
 677     {
 678       result = true;
 679     }
 680     else
 681     {
 682       result = false;
 683     }
 684   }
 685   catch (std::out_of_range& e)
 686   {
 687     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 688     return 0;
 689   }
 690   catch (std::exception& e)
 691   {
 692     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 693     return 0;
 694   }
 695   catch (DaliException e)
 696   {
 697     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 698     return 0;
 699   }
 700   catch (...)
 701   {
 702     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 703     return 0;
 704   }
 705   return result;
 706 }
 707
 708
 709 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 710      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 711    }
 712 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 713      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 714    }
 715 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 716         std::vector< Dali::TouchPoint >* pv = 0;
 717         if (capacity >= 0) {
 718           pv = new std::vector< Dali::TouchPoint >();
 719           pv->reserve(capacity);
 720        } else {
 721           throw std::out_of_range("capacity");
 722        }
 723        return pv;
 724       }
 725 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 726         if (index>=0 && index<(int)self->size())
 727           return (*self)[index];
 728         else
 729           throw std::out_of_range("index");
 730       }
 731 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 732         if (index>=0 && index<(int)self->size())
 733           return (*self)[index];
 734         else
 735           throw std::out_of_range("index");
 736       }
 737 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 738         if (index>=0 && index<(int)self->size())
 739           (*self)[index] = val;
 740         else
 741           throw std::out_of_range("index");
 742       }
 743 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 744         self->insert(self->end(), values.begin(), values.end());
 745       }
 746 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 747         if (index < 0)
 748           throw std::out_of_range("index");
 749         if (count < 0)
 750           throw std::out_of_range("count");
 751         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 752           throw std::invalid_argument("invalid range");
 753         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 754       }
 755 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 756         if (index>=0 && index<(int)self->size()+1)
 757           self->insert(self->begin()+index, x);
 758         else
 759           throw std::out_of_range("index");
 760       }
 761 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 762         if (index>=0 && index<(int)self->size()+1)
 763           self->insert(self->begin()+index, values.begin(), values.end());
 764         else
 765           throw std::out_of_range("index");
 766       }
 767 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 768         if (index>=0 && index<(int)self->size())
 769           self->erase(self->begin() + index);
 770         else
 771           throw std::out_of_range("index");
 772       }
 773 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 774         if (index < 0)
 775           throw std::out_of_range("index");
 776         if (count < 0)
 777           throw std::out_of_range("count");
 778         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 779           throw std::invalid_argument("invalid range");
 780         self->erase(self->begin()+index, self->begin()+index+count);
 781       }
 782 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 783         if (count < 0)
 784           throw std::out_of_range("count");
 785         return new std::vector< Dali::TouchPoint >(count, value);
 786       }
 787 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 788         std::reverse(self->begin(), self->end());
 789       }
 790 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 791         if (index < 0)
 792           throw std::out_of_range("index");
 793         if (count < 0)
 794           throw std::out_of_range("count");
 795         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 796           throw std::invalid_argument("invalid range");
 797         std::reverse(self->begin()+index, self->begin()+index+count);
 798       }
 799 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 800         if (index < 0)
 801           throw std::out_of_range("index");
 802         if (index+values.size() > self->size())
 803           throw std::out_of_range("index");
 804         std::copy(values.begin(), values.end(), self->begin()+index);
 805       }
 806 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 807          return self->Empty();
 808       }
 809 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 810         return self->GetConnectionCount();
 811       }
 812 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 813           self->Connect( func );
 814       }
 815 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 816           self->Disconnect( func );
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 819           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 820 /*@SWIG@*/ self->Emit( arg );
 821       }
 822 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 823          return self->Empty();
 824       }
 825 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 826         return self->GetConnectionCount();
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 829           self->Connect( func );
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 832           self->Disconnect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 835           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg );
 837       }
 838 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 839          return self->Empty();
 840       }
 841 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 842         return self->GetConnectionCount();
 843       }
 844 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 845           self->Connect( func );
 846       }
 847 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 848           self->Disconnect( func );
 849       }
 850 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 851           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 852 /*@SWIG@*/ self->Emit( arg );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 855          return self->Empty();
 856       }
 857 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 858         return self->GetConnectionCount();
 859       }
 860 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 861           self->Connect( func );
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 864           self->Disconnect( func );
 865       }
 866 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 867           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 868 /*@SWIG@*/ self->Emit( arg );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 871          return self->Empty();
 872       }
 873 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 874         return self->GetConnectionCount();
 875       }
 876 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 877           self->Connect( func );
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 880           self->Disconnect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 883           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 884 /*@SWIG@*/ self->Emit( arg );
 885       }
 886 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 887          return self->Empty();
 888       }
 889 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 890         return self->GetConnectionCount();
 891       }
 892 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 893         self->Connect( func );
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 896         self->Disconnect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 899         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 900 /*@SWIG@*/ self->Emit( arg1, arg2 );
 901       }
 902 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 903          return self->Empty();
 904       }
 905 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 906         return self->GetConnectionCount();
 907       }
 908 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 909         self->Connect( func );
 910       }
 911 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 912         self->Disconnect( func );
 913       }
 914 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 915         return self->Emit( arg1, arg2 );
 916       }
 917 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 918          return self->Empty();
 919       }
 920 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 921         return self->GetConnectionCount();
 922       }
 923 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 924         self->Connect( func );
 925       }
 926 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 927         self->Disconnect( func );
 928       }
 929 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 930         return self->Emit( arg1, arg2 );
 931       }
 932 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 933          return self->Empty();
 934       }
 935 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 936         return self->GetConnectionCount();
 937       }
 938 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 939         self->Connect( func );
 940       }
 941 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 942         self->Disconnect( func );
 943       }
 944 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 945         return self->Emit( arg1, arg2 );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 948          return self->Empty();
 949       }
 950 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 951         return self->GetConnectionCount();
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 954           self->Connect( func );
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Disconnect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 960           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg );
 962       }
 963 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 964          return self->Empty();
 965       }
 966 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 967         return self->GetConnectionCount();
 968       }
 969 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 970           self->Connect( func );
 971       }
 972 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 973           self->Disconnect( func );
 974       }
 975 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 976           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg );
 978       }
 979 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 980          return self->Empty();
 981       }
 982 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 983         return self->GetConnectionCount();
 984       }
 985 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 986           self->Connect( func );
 987       }
 988 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 989           self->Disconnect( func );
 990       }
 991 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 992           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 996          return self->Empty();
 997       }
 998 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 999         return self->GetConnectionCount();
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1002           self->Connect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1005           self->Disconnect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1012          return self->Empty();
1013       }
1014 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1015         return self->GetConnectionCount();
1016       }
1017 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1018         self->Connect( func );
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1021         self->Disconnect( func );
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1024         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg1, arg2 );
1026       }
1027 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1028          return self->Empty();
1029       }
1030 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1031         return self->GetConnectionCount();
1032       }
1033 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1034         self->Connect( func );
1035       }
1036 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1037         self->Disconnect( func );
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1040         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1041 /*@SWIG@*/ self->Emit( arg1, arg2 );
1042       }
1043 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1044          return self->Empty();
1045       }
1046 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1047         return self->GetConnectionCount();
1048       }
1049 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1050         self->Connect( func );
1051       }
1052 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1053         self->Disconnect( func );
1054       }
1055 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1056         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1057 /*@SWIG@*/ self->Emit( arg1, arg2 );
1058       }
1059 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1060          return self->Empty();
1061       }
1062 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1063         return self->GetConnectionCount();
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1066           self->Connect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1069           self->Disconnect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1072           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1073 /*@SWIG@*/ self->Emit( arg );
1074       }
1075 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1076          return self->Empty();
1077       }
1078 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1079         return self->GetConnectionCount();
1080       }
1081 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1082           return self->Connect( func );
1083       }
1084 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1085           self->Disconnect( func );
1086       }
1087 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1088           self->Emit( arg1, arg3 );
1089       }
1090 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1091          return self->Empty();
1092       }
1093 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1094         return self->GetConnectionCount();
1095       }
1096 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1097           return self->Connect( func );
1098       }
1099 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1100           self->Disconnect( func );
1101       }
1102 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1103           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1104 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1105       }
1106
1107 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1108          return self->Empty();
1109       }
1110 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1111         return self->GetConnectionCount();
1112       }
1113 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1114           self->Connect( func );
1115       }
1116 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1117           self->Disconnect( func );
1118       }
1119 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1120           return self->Emit();
1121       }
1122
1123 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1124         std::vector< unsigned int >* pv = 0;
1125         if (capacity >= 0) {
1126           pv = new std::vector< unsigned int >();
1127           pv->reserve(capacity);
1128        } else {
1129           throw std::out_of_range("capacity");
1130        }
1131        return pv;
1132       }
1133 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1134         if (index>=0 && index<(int)self->size())
1135           return (*self)[index];
1136         else
1137           throw std::out_of_range("index");
1138       }
1139 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1140         if (index>=0 && index<(int)self->size())
1141           return (*self)[index];
1142         else
1143           throw std::out_of_range("index");
1144       }
1145 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1146         if (index>=0 && index<(int)self->size())
1147           (*self)[index] = val;
1148         else
1149           throw std::out_of_range("index");
1150       }
1151 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1152         self->insert(self->end(), values.begin(), values.end());
1153       }
1154 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1164         if (index>=0 && index<(int)self->size()+1)
1165           self->insert(self->begin()+index, x);
1166         else
1167           throw std::out_of_range("index");
1168       }
1169 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1170         if (index>=0 && index<(int)self->size()+1)
1171           self->insert(self->begin()+index, values.begin(), values.end());
1172         else
1173           throw std::out_of_range("index");
1174       }
1175 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1176         if (index>=0 && index<(int)self->size())
1177           self->erase(self->begin() + index);
1178         else
1179           throw std::out_of_range("index");
1180       }
1181 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1182         if (index < 0)
1183           throw std::out_of_range("index");
1184         if (count < 0)
1185           throw std::out_of_range("count");
1186         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1187           throw std::invalid_argument("invalid range");
1188         self->erase(self->begin()+index, self->begin()+index+count);
1189       }
1190 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1191         if (count < 0)
1192           throw std::out_of_range("count");
1193         return new std::vector< unsigned int >(count, value);
1194       }
1195 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1196         std::reverse(self->begin(), self->end());
1197       }
1198 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1199         if (index < 0)
1200           throw std::out_of_range("index");
1201         if (count < 0)
1202           throw std::out_of_range("count");
1203         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1204           throw std::invalid_argument("invalid range");
1205         std::reverse(self->begin()+index, self->begin()+index+count);
1206       }
1207 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1208         if (index < 0)
1209           throw std::out_of_range("index");
1210         if (index+values.size() > self->size())
1211           throw std::out_of_range("index");
1212         std::copy(values.begin(), values.end(), self->begin()+index);
1213       }
1214 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1215         return std::find(self->begin(), self->end(), value) != self->end();
1216       }
1217 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1218         int index = -1;
1219         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1220         if (it != self->end())
1221           index = (int)(it - self->begin());
1222         return index;
1223       }
1224 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1225         int index = -1;
1226         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1227         if (rit != self->rend())
1228           index = (int)(self->rend() - 1 - rit);
1229         return index;
1230       }
1231 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1232         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1233         if (it != self->end()) {
1234           self->erase(it);
1235           return true;
1236         }
1237         return false;
1238       }
1239 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1240         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1241         if (capacity >= 0) {
1242           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1243           pv->reserve(capacity);
1244        } else {
1245           throw std::out_of_range("capacity");
1246        }
1247        return pv;
1248       }
1249 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1250         if (index>=0 && index<(int)self->size())
1251           return (*self)[index];
1252         else
1253           throw std::out_of_range("index");
1254       }
1255 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1256         if (index>=0 && index<(int)self->size())
1257           return (*self)[index];
1258         else
1259           throw std::out_of_range("index");
1260       }
1261 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1262         if (index>=0 && index<(int)self->size())
1263           (*self)[index] = val;
1264         else
1265           throw std::out_of_range("index");
1266       }
1267 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1268         self->insert(self->end(), values.begin(), values.end());
1269       }
1270 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1278       }
1279 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1280         if (index>=0 && index<(int)self->size()+1)
1281           self->insert(self->begin()+index, x);
1282         else
1283           throw std::out_of_range("index");
1284       }
1285 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1286         if (index>=0 && index<(int)self->size()+1)
1287           self->insert(self->begin()+index, values.begin(), values.end());
1288         else
1289           throw std::out_of_range("index");
1290       }
1291 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1292         if (index>=0 && index<(int)self->size())
1293           self->erase(self->begin() + index);
1294         else
1295           throw std::out_of_range("index");
1296       }
1297 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1298         if (index < 0)
1299           throw std::out_of_range("index");
1300         if (count < 0)
1301           throw std::out_of_range("count");
1302         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1303           throw std::invalid_argument("invalid range");
1304         self->erase(self->begin()+index, self->begin()+index+count);
1305       }
1306 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1307         if (count < 0)
1308           throw std::out_of_range("count");
1309         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1310       }
1311 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1312         std::reverse(self->begin(), self->end());
1313       }
1314 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1315         if (index < 0)
1316           throw std::out_of_range("index");
1317         if (count < 0)
1318           throw std::out_of_range("count");
1319         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1320           throw std::invalid_argument("invalid range");
1321         std::reverse(self->begin()+index, self->begin()+index+count);
1322       }
1323 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1324         if (index < 0)
1325           throw std::out_of_range("index");
1326         if (index+values.size() > self->size())
1327           throw std::out_of_range("index");
1328         std::copy(values.begin(), values.end(), self->begin()+index);
1329       }
1330 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1331         std::vector< Dali::Actor >* pv = 0;
1332         if (capacity >= 0) {
1333           pv = new std::vector< Dali::Actor >();
1334           pv->reserve(capacity);
1335        } else {
1336           throw std::out_of_range("capacity");
1337        }
1338        return pv;
1339       }
1340 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1341         if (index>=0 && index<(int)self->size())
1342           return (*self)[index];
1343         else
1344           throw std::out_of_range("index");
1345       }
1346 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1347         if (index>=0 && index<(int)self->size())
1348           return (*self)[index];
1349         else
1350           throw std::out_of_range("index");
1351       }
1352 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1353         if (index>=0 && index<(int)self->size())
1354           (*self)[index] = val;
1355         else
1356           throw std::out_of_range("index");
1357       }
1358 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1359         self->insert(self->end(), values.begin(), values.end());
1360       }
1361 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1371         if (index>=0 && index<(int)self->size()+1)
1372           self->insert(self->begin()+index, x);
1373         else
1374           throw std::out_of_range("index");
1375       }
1376 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1377         if (index>=0 && index<(int)self->size()+1)
1378           self->insert(self->begin()+index, values.begin(), values.end());
1379         else
1380           throw std::out_of_range("index");
1381       }
1382 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1383         if (index>=0 && index<(int)self->size())
1384           self->erase(self->begin() + index);
1385         else
1386           throw std::out_of_range("index");
1387       }
1388 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1389         if (index < 0)
1390           throw std::out_of_range("index");
1391         if (count < 0)
1392           throw std::out_of_range("count");
1393         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1394           throw std::invalid_argument("invalid range");
1395         self->erase(self->begin()+index, self->begin()+index+count);
1396       }
1397 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1398         if (count < 0)
1399           throw std::out_of_range("count");
1400         return new std::vector< Dali::Actor >(count, value);
1401       }
1402 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1403         std::reverse(self->begin(), self->end());
1404       }
1405 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1406         if (index < 0)
1407           throw std::out_of_range("index");
1408         if (count < 0)
1409           throw std::out_of_range("count");
1410         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1411           throw std::invalid_argument("invalid range");
1412         std::reverse(self->begin()+index, self->begin()+index+count);
1413       }
1414 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1415         if (index < 0)
1416           throw std::out_of_range("index");
1417         if (index+values.size() > self->size())
1418           throw std::out_of_range("index");
1419         std::copy(values.begin(), values.end(), self->begin()+index);
1420       }
1421 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1422          return self->Empty();
1423       }
1424 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1425         return self->GetConnectionCount();
1426       }
1427 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1428           self->Connect( func );
1429       }
1430 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1431           self->Disconnect( func );
1432       }
1433 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1434           return self->Emit( arg );
1435       }
1436 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1437          return self->Empty();
1438       }
1439 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1440         return self->GetConnectionCount();
1441       }
1442 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1443         self->Connect( func );
1444       }
1445 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1446         self->Disconnect( func );
1447       }
1448 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1449         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg1, arg2 );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1453          return self->Empty();
1454       }
1455 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1456         return self->GetConnectionCount();
1457       }
1458 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1459         self->Connect( func );
1460       }
1461 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1462         self->Disconnect( func );
1463       }
1464 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1465         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg1, arg2 );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1469          return self->Empty();
1470       }
1471 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1472         return self->GetConnectionCount();
1473       }
1474 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1475         self->Connect( func );
1476       }
1477 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1478         self->Disconnect( func );
1479       }
1480 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1481         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2 );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1485          return self->Empty();
1486       }
1487 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1488         return self->GetConnectionCount();
1489       }
1490 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1491         self->Connect( func );
1492       }
1493 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1494         self->Disconnect( func );
1495       }
1496 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1497         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1498 /*@SWIG@*/ self->Emit( arg1, arg2 );
1499       }
1500 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1501          return self->Empty();
1502       }
1503 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1504         return self->GetConnectionCount();
1505       }
1506 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1507           self->Connect( func );
1508       }
1509 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1510           self->Disconnect( func );
1511       }
1512 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1513           return self->Emit( arg );
1514       }
1515 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1516          return self->Empty();
1517       }
1518 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1519         return self->GetConnectionCount();
1520       }
1521 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1522           self->Connect( func );
1523       }
1524 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1525           self->Disconnect( func );
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1528           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1529 /*@SWIG@*/ self->Emit( arg );
1530       }
1531 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1532          return self->Empty();
1533       }
1534 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1535         return self->GetConnectionCount();
1536       }
1537 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1538           return self->Connect( func );
1539       }
1540 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1541           self->Disconnect( func );
1542       }
1543 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1544           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1545 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1546       }
1547 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1548          return self->Empty();
1549       }
1550 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1551         return self->GetConnectionCount();
1552       }
1553 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1554           self->Connect( func );
1555       }
1556 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1557           self->Disconnect( func );
1558       }
1559 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1560           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1561 /*@SWIG@*/ self->Emit( arg );
1562       }
1563 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1564          return self->Empty();
1565       }
1566 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1567         return self->GetConnectionCount();
1568       }
1569 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1570           return self->Connect( func );
1571       }
1572 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1573           self->Disconnect( func );
1574       }
1575 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1576           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1577 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1578       }
1579 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1580          return self->Empty();
1581       }
1582 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1583         return self->GetConnectionCount();
1584       }
1585 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1586           self->Connect( func );
1587       }
1588 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1589           self->Disconnect( func );
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1596          return self->Empty();
1597       }
1598 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1599         return self->GetConnectionCount();
1600       }
1601 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1602           self->Connect( func );
1603       }
1604 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1605           self->Disconnect( func );
1606       }
1607 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1608           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1609 /*@SWIG@*/ self->Emit( arg );
1610       }
1611
1612
1613 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1614          return self->Empty();
1615       }
1616 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1617         return self->GetConnectionCount();
1618       }
1619 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1620         self->Connect( func );
1621       }
1622 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1623         self->Disconnect( func );
1624       }
1625 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1626         return self->Emit( arg1, arg2 );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1635           self->Connect( func );
1636       }
1637 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1638           self->Disconnect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1645          return self->Empty();
1646       }
1647 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1648         return self->GetConnectionCount();
1649       }
1650 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1651           self->Connect( func );
1652       }
1653 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1654           self->Disconnect( func );
1655       }
1656 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1657           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1658 /*@SWIG@*/ self->Emit( arg );
1659       }
1660 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1661          return self->Empty();
1662       }
1663 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1664         return self->GetConnectionCount();
1665       }
1666 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1667         self->Connect( func );
1668       }
1669 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1670         self->Disconnect( func );
1671       }
1672 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1673         return self->Emit( arg1, arg2 );
1674       }
1675 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1676          return self->Empty();
1677       }
1678 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1679         return self->GetConnectionCount();
1680       }
1681 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1682         self->Connect( func );
1683       }
1684 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1685         self->Disconnect( func );
1686       }
1687 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1688         return self->Emit( arg1, arg2 );
1689       }
1690
1691 /* ---------------------------------------------------
1692  * C++ director class methods
1693  * --------------------------------------------------- */
1694
1695 #include "dali_wrap.h"
1696
1697 /*
1698  *  Widget director
1699  */
1700 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1701   swig_init_callbacks();
1702 }
1703
1704 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1705 }
1706
1707 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1708   char * jcontentInfo = 0 ;
1709   void * jwindow  ;
1710
1711   if (!swig_callbackOnCreate) {
1712     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1713     return;
1714   } else {
1715     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1716     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1717     swig_callbackOnCreate(jcontentInfo, jwindow);
1718   }
1719 }
1720
1721 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1722   char * jcontentInfo = 0 ;
1723   int jtype  ;
1724
1725   if (!swig_callbackOnTerminate) {
1726     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1727     return;
1728   } else {
1729     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1730     jtype = (int)type;
1731     swig_callbackOnTerminate(jcontentInfo, jtype);
1732   }
1733 }
1734
1735 void SwigDirector_WidgetImpl::OnPause() {
1736   if (!swig_callbackOnPause) {
1737     Dali::Internal::Adaptor::Widget::OnPause();
1738     return;
1739   } else {
1740     swig_callbackOnPause();
1741   }
1742 }
1743
1744 void SwigDirector_WidgetImpl::OnResume() {
1745   if (!swig_callbackOnResume) {
1746     Dali::Internal::Adaptor::Widget::OnResume();
1747     return;
1748   } else {
1749     swig_callbackOnResume();
1750   }
1751 }
1752
1753 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1754   void * jwindow  ;
1755
1756   if (!swig_callbackOnResize) {
1757     Dali::Internal::Adaptor::Widget::OnResize(window);
1758     return;
1759   } else {
1760     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1761     swig_callbackOnResize(jwindow);
1762   }
1763 }
1764
1765 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1766   char * jcontentInfo = 0 ;
1767   int jforce  ;
1768
1769   if (!swig_callbackOnUpdate) {
1770     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1771     return;
1772   } else {
1773     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1774     jforce = force;
1775     swig_callbackOnUpdate(jcontentInfo, jforce);
1776   }
1777 }
1778
1779 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1780   void * jslotObserver = 0 ;
1781   void * jcallback = 0 ;
1782
1783   if (!swig_callbackSignalConnected) {
1784     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1785     return;
1786   } else {
1787     jslotObserver = (void *) slotObserver;
1788     jcallback = (void *) callback;
1789     swig_callbackSignalConnected(jslotObserver, jcallback);
1790   }
1791 }
1792
1793 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1794   void * jslotObserver = 0 ;
1795   void * jcallback = 0 ;
1796
1797   if (!swig_callbackSignalDisconnected) {
1798     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1799     return;
1800   } else {
1801     jslotObserver = (void *) slotObserver;
1802     jcallback = (void *) callback;
1803     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1804   }
1805 }
1806
1807 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1808
1809   swig_callbackOnCreate = callbackOnCreate;
1810   swig_callbackOnTerminate = callbackOnTerminate;
1811   swig_callbackOnPause = callbackOnPause;
1812   swig_callbackOnResume = callbackOnResume;
1813   swig_callbackOnResize = callbackOnResize;
1814   swig_callbackOnUpdate = callbackOnUpdate;
1815   swig_callbackSignalConnected = callbackSignalConnected;
1816   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1817 }
1818
1819 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1820   swig_callbackOnCreate = 0;
1821   swig_callbackOnTerminate = 0;
1822   swig_callbackOnPause = 0;
1823   swig_callbackOnResume = 0;
1824   swig_callbackOnResize = 0;
1825   swig_callbackOnUpdate = 0;
1826   swig_callbackSignalConnected = 0;
1827   swig_callbackSignalDisconnected = 0;
1828 }
1829
1830
1831 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1832   swig_init_callbacks();
1833 }
1834
1835 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1836
1837 }
1838
1839
1840 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1841   int jdepth  ;
1842
1843   if (!swig_callbackOnStageConnection) {
1844     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1845     return;
1846   } else {
1847     jdepth = depth;
1848     swig_callbackOnStageConnection(jdepth);
1849   }
1850 }
1851
1852 void SwigDirector_ViewImpl::OnStageDisconnection() {
1853   if (!swig_callbackOnStageDisconnection) {
1854     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1855     return;
1856   } else {
1857     swig_callbackOnStageDisconnection();
1858   }
1859 }
1860
1861 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1862   void * jchild = 0 ;
1863
1864   if (!swig_callbackOnChildAdd) {
1865     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1866     return;
1867   } else {
1868     jchild = (Dali::Actor *) &child;
1869     swig_callbackOnChildAdd(jchild);
1870   }
1871 }
1872
1873 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1874   void * jchild = 0 ;
1875
1876   if (!swig_callbackOnChildRemove) {
1877     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1878     return;
1879   } else {
1880     jchild = (Dali::Actor *) &child;
1881     swig_callbackOnChildRemove(jchild);
1882   }
1883 }
1884
1885 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1886   int jindex  ;
1887   void * jpropertyValue  ;
1888
1889   if (!swig_callbackOnPropertySet) {
1890     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1891     return;
1892   } else {
1893     jindex = index;
1894     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1895     swig_callbackOnPropertySet(jindex, jpropertyValue);
1896   }
1897 }
1898
1899 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1900   void * jtargetSize = 0 ;
1901
1902   if (!swig_callbackOnSizeSet) {
1903     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1904     return;
1905   } else {
1906     jtargetSize = (Dali::Vector3 *) &targetSize;
1907     swig_callbackOnSizeSet(jtargetSize);
1908   }
1909 }
1910
1911 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1912   void * janimation = 0 ;
1913   void * jtargetSize = 0 ;
1914
1915   if (!swig_callbackOnSizeAnimation) {
1916     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1917     return;
1918   } else {
1919     janimation = (Dali::Animation *) &animation;
1920     jtargetSize = (Dali::Vector3 *) &targetSize;
1921     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1922   }
1923 }
1924
1925 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1926   bool c_result = SwigValueInit< bool >() ;
1927   unsigned int jresult = 0 ;
1928   void * jarg0 = 0 ;
1929
1930   if (!swig_callbackOnTouchEvent) {
1931     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1932   } else {
1933     jarg0 = (Dali::TouchEvent *) &event;
1934     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1935     c_result = jresult ? true : false;
1936   }
1937   return c_result;
1938 }
1939
1940 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1941   bool c_result = SwigValueInit< bool >() ;
1942   unsigned int jresult = 0 ;
1943   void * jarg0 = 0 ;
1944
1945   if (!swig_callbackOnHoverEvent) {
1946     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1947   } else {
1948     jarg0 = (Dali::HoverEvent *) &event;
1949     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1950     c_result = jresult ? true : false;
1951   }
1952   return c_result;
1953 }
1954
1955 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1956   bool c_result = SwigValueInit< bool >() ;
1957   unsigned int jresult = 0 ;
1958   void * jarg0 = 0 ;
1959
1960   if (!swig_callbackOnKeyEvent) {
1961     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1962   } else {
1963     jarg0 = (Dali::KeyEvent *) &event;
1964     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1965     c_result = jresult ? true : false;
1966   }
1967   return c_result;
1968 }
1969
1970 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1971   bool c_result = SwigValueInit< bool >() ;
1972   unsigned int jresult = 0 ;
1973   void * jarg0 = 0 ;
1974
1975   if (!swig_callbackOnWheelEvent) {
1976     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1977   } else {
1978     jarg0 = (Dali::WheelEvent *) &event;
1979     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1980     c_result = jresult ? true : false;
1981   }
1982   return c_result;
1983 }
1984
1985 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1986   void * jsize = 0 ;
1987   void * jcontainer = 0 ;
1988
1989   if (!swig_callbackOnRelayout) {
1990     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1991     return;
1992   } else {
1993     jsize = (Dali::Vector2 *) &size;
1994     jcontainer = (Dali::RelayoutContainer *) &container;
1995     swig_callbackOnRelayout(jsize, jcontainer);
1996   }
1997 }
1998
1999 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2000   int jpolicy  ;
2001   int jdimension  ;
2002
2003   if (!swig_callbackOnSetResizePolicy) {
2004     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2005     return;
2006   } else {
2007     jpolicy = (int)policy;
2008     jdimension = (int)dimension;
2009     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2010   }
2011 }
2012
2013 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2014   Dali::Vector3 c_result ;
2015   void * jresult = 0 ;
2016
2017   if (!swig_callbackGetNaturalSize) {
2018     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2019   } else {
2020     jresult = (void *) swig_callbackGetNaturalSize();
2021     if (!jresult) {
2022       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2023       return c_result;
2024     }
2025     c_result = *(Dali::Vector3 *)jresult;
2026   }
2027   return c_result;
2028 }
2029
2030 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2031   float c_result = SwigValueInit< float >() ;
2032   float jresult = 0 ;
2033   void * jchild = 0 ;
2034   int jdimension  ;
2035
2036   if (!swig_callbackCalculateChildSize) {
2037     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2038   } else {
2039     jchild = (Dali::Actor *) &child;
2040     jdimension = (int)dimension;
2041     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2042     c_result = (float)jresult;
2043   }
2044   return c_result;
2045 }
2046
2047 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2048   float c_result = SwigValueInit< float >() ;
2049   float jresult = 0 ;
2050   float jwidth  ;
2051
2052   if (!swig_callbackGetHeightForWidth) {
2053     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2054   } else {
2055     jwidth = width;
2056     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2057     c_result = (float)jresult;
2058   }
2059   return c_result;
2060 }
2061
2062 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2063   float c_result = SwigValueInit< float >() ;
2064   float jresult = 0 ;
2065   float jheight  ;
2066
2067   if (!swig_callbackGetWidthForHeight) {
2068     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2069   } else {
2070     jheight = height;
2071     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2072     c_result = (float)jresult;
2073   }
2074   return c_result;
2075 }
2076
2077 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2078   bool c_result = SwigValueInit< bool >() ;
2079   unsigned int jresult = 0 ;
2080   int jdimension  ;
2081
2082   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2083     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2084   } else {
2085     jdimension = (int)dimension;
2086     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2087     c_result = jresult ? true : false;
2088   }
2089   return c_result;
2090 }
2091
2092 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2093   int jdimension  ;
2094
2095   if (!swig_callbackOnCalculateRelayoutSize) {
2096     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2097     return;
2098   } else {
2099     jdimension = (int)dimension;
2100     swig_callbackOnCalculateRelayoutSize(jdimension);
2101   }
2102 }
2103
2104 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2105   float jsize  ;
2106   int jdimension  ;
2107
2108   if (!swig_callbackOnLayoutNegotiated) {
2109     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2110     return;
2111   } else {
2112     jsize = size;
2113     jdimension = (int)dimension;
2114     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2115   }
2116 }
2117
2118 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2119   return Dali::CustomActorImpl::GetExtension();
2120 }
2121
2122 void SwigDirector_ViewImpl::OnInitialize() {
2123   if (!swig_callbackOnInitialize) {
2124     Dali::Toolkit::Internal::Control::OnInitialize();
2125     return;
2126   } else {
2127     swig_callbackOnInitialize();
2128   }
2129 }
2130
2131 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2132   void * jchild = 0 ;
2133
2134   if (!swig_callbackOnControlChildAdd) {
2135     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2136     return;
2137   } else {
2138     jchild = (Dali::Actor *) &child;
2139     swig_callbackOnControlChildAdd(jchild);
2140   }
2141 }
2142
2143 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2144   void * jchild = 0 ;
2145
2146   if (!swig_callbackOnControlChildRemove) {
2147     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2148     return;
2149   } else {
2150     jchild = (Dali::Actor *) &child;
2151     swig_callbackOnControlChildRemove(jchild);
2152   }
2153 }
2154
2155 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2156   void * jstyleManager  ;
2157   int jchange  ;
2158
2159   if (!swig_callbackOnStyleChange) {
2160     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2161     return;
2162   } else {
2163     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2164     jchange = (int)change;
2165     swig_callbackOnStyleChange(jstyleManager, jchange);
2166   }
2167 }
2168
2169 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2170   bool c_result = SwigValueInit< bool >() ;
2171   unsigned int jresult = 0 ;
2172
2173   if (!swig_callbackOnAccessibilityActivated) {
2174     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2175   } else {
2176     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2177     c_result = jresult ? true : false;
2178   }
2179   return c_result;
2180 }
2181
2182 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2183   bool c_result = SwigValueInit< bool >() ;
2184   unsigned int jresult = 0 ;
2185   void * jgesture  ;
2186
2187   if (!swig_callbackOnAccessibilityPan) {
2188     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2189   } else {
2190     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2191     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2192     c_result = jresult ? true : false;
2193   }
2194   return c_result;
2195 }
2196
2197 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2198   bool c_result = SwigValueInit< bool >() ;
2199   unsigned int jresult = 0 ;
2200   void * jtouchEvent = 0 ;
2201
2202   if (!swig_callbackOnAccessibilityTouch) {
2203     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2204   } else {
2205     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2206     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2207     c_result = jresult ? true : false;
2208   }
2209   return c_result;
2210 }
2211
2212 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2213   bool c_result = SwigValueInit< bool >() ;
2214   unsigned int jresult = 0 ;
2215   unsigned int jisIncrease  ;
2216
2217   if (!swig_callbackOnAccessibilityValueChange) {
2218     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2219   } else {
2220     jisIncrease = isIncrease;
2221     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2222     c_result = jresult ? true : false;
2223   }
2224   return c_result;
2225 }
2226
2227 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2228   bool c_result = SwigValueInit< bool >() ;
2229   unsigned int jresult = 0 ;
2230
2231   if (!swig_callbackOnAccessibilityZoom) {
2232     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2233   } else {
2234     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2235     c_result = jresult ? true : false;
2236   }
2237   return c_result;
2238 }
2239
2240 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2241   if (!swig_callbackOnKeyInputFocusGained) {
2242     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2243     return;
2244   } else {
2245     swig_callbackOnKeyInputFocusGained();
2246   }
2247 }
2248
2249 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2250   if (!swig_callbackOnKeyInputFocusLost) {
2251     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2252     return;
2253   } else {
2254     swig_callbackOnKeyInputFocusLost();
2255   }
2256 }
2257
2258 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2259   Dali::Actor c_result ;
2260   void * jresult = 0 ;
2261   void * jcurrentFocusedActor  ;
2262   int jdirection  ;
2263   unsigned int jloopEnabled  ;
2264
2265   if (!swig_callbackGetNextKeyboardFocusableActor) {
2266     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2267   } else {
2268     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2269     jdirection = (int)direction;
2270     jloopEnabled = loopEnabled;
2271     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2272     if (!jresult) {
2273       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2274       return c_result;
2275     }
2276     c_result = *(Dali::Actor *)jresult;
2277   }
2278   return c_result;
2279 }
2280
2281 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2282   void * jcommitedFocusableActor  ;
2283
2284   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2285     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2286     return;
2287   } else {
2288     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2289     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2290   }
2291 }
2292
2293 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2294   bool c_result = SwigValueInit< bool >() ;
2295   unsigned int jresult = 0 ;
2296
2297   if (!swig_callbackOnKeyboardEnter) {
2298     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2299   } else {
2300     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2301     c_result = jresult ? true : false;
2302   }
2303   return c_result;
2304 }
2305
2306 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2307   void * jpinch = 0 ;
2308
2309   if (!swig_callbackOnPinch) {
2310     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2311     return;
2312   } else {
2313     jpinch = (Dali::PinchGesture *) &pinch;
2314     swig_callbackOnPinch(jpinch);
2315   }
2316 }
2317
2318 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2319   void * jpan = 0 ;
2320
2321   if (!swig_callbackOnPan) {
2322     Dali::Toolkit::Internal::Control::OnPan(pan);
2323     return;
2324   } else {
2325     jpan = (Dali::PanGesture *) &pan;
2326     swig_callbackOnPan(jpan);
2327   }
2328 }
2329
2330 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2331   void * jtap = 0 ;
2332
2333   if (!swig_callbackOnTap) {
2334     Dali::Toolkit::Internal::Control::OnTap(tap);
2335     return;
2336   } else {
2337     jtap = (Dali::TapGesture *) &tap;
2338     swig_callbackOnTap(jtap);
2339   }
2340 }
2341
2342 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2343   void * jlongPress = 0 ;
2344
2345   if (!swig_callbackOnLongPress) {
2346     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2347     return;
2348   } else {
2349     jlongPress = (Dali::LongPressGesture *) &longPress;
2350     swig_callbackOnLongPress(jlongPress);
2351   }
2352 }
2353
2354 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2355   void * jslotObserver = 0 ;
2356   void * jcallback = 0 ;
2357
2358   if (!swig_callbackSignalConnected) {
2359     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2360     return;
2361   } else {
2362     jslotObserver = (void *) slotObserver;
2363     jcallback = (void *) callback;
2364     swig_callbackSignalConnected(jslotObserver, jcallback);
2365   }
2366 }
2367
2368 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2369   void * jslotObserver = 0 ;
2370   void * jcallback = 0 ;
2371
2372   if (!swig_callbackSignalDisconnected) {
2373     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2374     return;
2375   } else {
2376     jslotObserver = (void *) slotObserver;
2377     jcallback = (void *) callback;
2378     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2379   }
2380 }
2381
2382 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2383   return Dali::Toolkit::Internal::Control::GetControlExtension();
2384 }
2385
2386 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2387   swig_callbackOnStageConnection = callbackOnStageConnection;
2388   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2389   swig_callbackOnChildAdd = callbackOnChildAdd;
2390   swig_callbackOnChildRemove = callbackOnChildRemove;
2391   swig_callbackOnPropertySet = callbackOnPropertySet;
2392   swig_callbackOnSizeSet = callbackOnSizeSet;
2393   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2394   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2395   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2396   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2397   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2398   swig_callbackOnRelayout = callbackOnRelayout;
2399   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2400   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2401   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2402   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2403   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2404   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2405   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2406   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2407   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2408   swig_callbackOnInitialize = callbackOnInitialize;
2409   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2410   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2411   swig_callbackOnStyleChange = callbackOnStyleChange;
2412   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2413   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2414   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2415   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2416   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2417   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2418   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2419   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2420   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2421   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2422   swig_callbackOnPinch = callbackOnPinch;
2423   swig_callbackOnPan = callbackOnPan;
2424   swig_callbackOnTap = callbackOnTap;
2425   swig_callbackOnLongPress = callbackOnLongPress;
2426   swig_callbackSignalConnected = callbackSignalConnected;
2427   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2428 }
2429
2430 void SwigDirector_ViewImpl::swig_init_callbacks() {
2431   swig_callbackOnStageConnection = 0;
2432   swig_callbackOnStageDisconnection = 0;
2433   swig_callbackOnChildAdd = 0;
2434   swig_callbackOnChildRemove = 0;
2435   swig_callbackOnPropertySet = 0;
2436   swig_callbackOnSizeSet = 0;
2437   swig_callbackOnSizeAnimation = 0;
2438   swig_callbackOnTouchEvent = 0;
2439   swig_callbackOnHoverEvent = 0;
2440   swig_callbackOnKeyEvent = 0;
2441   swig_callbackOnWheelEvent = 0;
2442   swig_callbackOnRelayout = 0;
2443   swig_callbackOnSetResizePolicy = 0;
2444   swig_callbackGetNaturalSize = 0;
2445   swig_callbackCalculateChildSize = 0;
2446   swig_callbackGetHeightForWidth = 0;
2447   swig_callbackGetWidthForHeight = 0;
2448   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2449   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2450   swig_callbackOnCalculateRelayoutSize = 0;
2451   swig_callbackOnLayoutNegotiated = 0;
2452   swig_callbackOnInitialize = 0;
2453   swig_callbackOnControlChildAdd = 0;
2454   swig_callbackOnControlChildRemove = 0;
2455   swig_callbackOnStyleChange = 0;
2456   swig_callbackOnAccessibilityActivated = 0;
2457   swig_callbackOnAccessibilityPan = 0;
2458   swig_callbackOnAccessibilityTouch = 0;
2459   swig_callbackOnAccessibilityValueChange = 0;
2460   swig_callbackOnAccessibilityZoom = 0;
2461   swig_callbackOnKeyInputFocusGained = 0;
2462   swig_callbackOnKeyInputFocusLost = 0;
2463   swig_callbackGetNextKeyboardFocusableActor = 0;
2464   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2465   swig_callbackOnKeyboardEnter = 0;
2466   swig_callbackOnPinch = 0;
2467   swig_callbackOnPan = 0;
2468   swig_callbackOnTap = 0;
2469   swig_callbackOnLongPress = 0;
2470   swig_callbackSignalConnected = 0;
2471   swig_callbackSignalDisconnected = 0;
2472 }
2473
2474 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2475   swig_init_callbacks();
2476 }
2477
2478 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2479
2480 }
2481
2482
2483 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2484   unsigned int c_result = SwigValueInit< unsigned int >() ;
2485   unsigned int jresult = 0 ;
2486
2487   if (!swig_callbackGetNumberOfItems) {
2488     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2489   } else {
2490     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2491     c_result = (unsigned int)jresult;
2492   }
2493   return c_result;
2494 }
2495
2496 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2497   Dali::Actor c_result ;
2498   void * jresult = 0 ;
2499   unsigned int jitemId  ;
2500
2501   if (!swig_callbackNewItem) {
2502     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2503   } else {
2504     jitemId = itemId;
2505     jresult = (void *) swig_callbackNewItem(jitemId);
2506     if (!jresult) {
2507       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2508       return c_result;
2509     }
2510     c_result = *(Dali::Actor *)jresult;
2511   }
2512   return c_result;
2513 }
2514
2515 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2516   unsigned int jitemId  ;
2517   void * jactor  ;
2518
2519   if (!swig_callbackItemReleased) {
2520     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2521     return;
2522   } else {
2523     jitemId = itemId;
2524     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2525     swig_callbackItemReleased(jitemId, jactor);
2526   }
2527 }
2528
2529 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2530   return Dali::Toolkit::ItemFactory::GetExtension();
2531 }
2532
2533 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2534   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2535   swig_callbackNewItem = callbackNewItem;
2536   swig_callbackItemReleased = callbackItemReleased;
2537 }
2538
2539 void SwigDirector_ItemFactory::swig_init_callbacks() {
2540   swig_callbackGetNumberOfItems = 0;
2541   swig_callbackNewItem = 0;
2542   swig_callbackItemReleased = 0;
2543 }
2544
2545 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2546   swig_init_callbacks();
2547 }
2548
2549 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2550
2551 }
2552
2553
2554 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2555   Dali::Actor c_result ;
2556   void * jresult = 0 ;
2557   void * jcurrent  ;
2558   void * jproposed  ;
2559   int jdirection  ;
2560
2561   if (!swig_callbackGetNextFocusableActor) {
2562     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2563   } else {
2564     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2565     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2566     jdirection = (int)direction;
2567     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2568     if (!jresult) {
2569       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2570       return c_result;
2571     }
2572     c_result = *(Dali::Actor *)jresult;
2573   }
2574   return c_result;
2575 }
2576
2577 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2578   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2579 }
2580
2581 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2582   swig_callbackGetNextFocusableActor = 0;
2583 }
2584
2585
2586 #ifdef __cplusplus
2587 extern "C" {
2588 #endif
2589
2590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2591   void * jresult ;
2592   floatp *result = 0 ;
2593
2594   {
2595     try {
2596       result = (floatp *)new_floatp();
2597     } catch (std::out_of_range& e) {
2598       {
2599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2600       };
2601     } catch (std::exception& e) {
2602       {
2603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2604       };
2605     } catch (DaliException e) {
2606       {
2607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2608       };
2609     } catch (...) {
2610       {
2611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2612       };
2613     }
2614   }
2615   jresult = (void *)result;
2616   return jresult;
2617 }
2618
2619
2620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2621   floatp *arg1 = (floatp *) 0 ;
2622
2623   arg1 = (floatp *)jarg1;
2624   {
2625     try {
2626       delete_floatp(arg1);
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2634       };
2635     } catch (Dali::DaliException e) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2638       };
2639     } catch (...) {
2640       {
2641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2642       };
2643     }
2644   }
2645
2646 }
2647
2648
2649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2650   floatp *arg1 = (floatp *) 0 ;
2651   float arg2 ;
2652
2653   arg1 = (floatp *)jarg1;
2654   arg2 = (float)jarg2;
2655   {
2656     try {
2657       floatp_assign(arg1,arg2);
2658     } catch (std::out_of_range& e) {
2659       {
2660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2661       };
2662     } catch (std::exception& e) {
2663       {
2664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2665       };
2666     } catch (Dali::DaliException e) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2669       };
2670     } catch (...) {
2671       {
2672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2673       };
2674     }
2675   }
2676
2677 }
2678
2679
2680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2681   float jresult ;
2682   floatp *arg1 = (floatp *) 0 ;
2683   float result;
2684
2685   arg1 = (floatp *)jarg1;
2686   {
2687     try {
2688       result = (float)floatp_value(arg1);
2689     } catch (std::out_of_range& e) {
2690       {
2691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2692       };
2693     } catch (std::exception& e) {
2694       {
2695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2696       };
2697     } catch (DaliException e) {
2698       {
2699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2700       };
2701     } catch (...) {
2702       {
2703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2704       };
2705     }
2706   }
2707   jresult = result;
2708   return jresult;
2709 }
2710
2711
2712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2713   void * jresult ;
2714   floatp *arg1 = (floatp *) 0 ;
2715   float *result = 0 ;
2716
2717   arg1 = (floatp *)jarg1;
2718   {
2719     try {
2720       result = (float *)floatp_cast(arg1);
2721     } catch (std::out_of_range& e) {
2722       {
2723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2724       };
2725     } catch (std::exception& e) {
2726       {
2727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2728       };
2729     } catch (Dali::DaliException e) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2732       };
2733     } catch (...) {
2734       {
2735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2736       };
2737     }
2738   }
2739
2740   jresult = (void *)result;
2741   return jresult;
2742 }
2743
2744
2745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2746   void * jresult ;
2747   float *arg1 = (float *) 0 ;
2748   floatp *result = 0 ;
2749
2750   arg1 = (float *)jarg1;
2751   {
2752     try {
2753       result = (floatp *)floatp_frompointer(arg1);
2754     } catch (std::out_of_range& e) {
2755       {
2756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (std::exception& e) {
2759       {
2760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2761       };
2762     } catch (Dali::DaliException e) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2765       };
2766     } catch (...) {
2767       {
2768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2769       };
2770     }
2771   }
2772
2773   jresult = (void *)result;
2774   return jresult;
2775 }
2776
2777
2778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2779   void * jresult ;
2780   intp *result = 0 ;
2781
2782   {
2783     try {
2784       result = (intp *)new_intp();
2785     } catch (std::out_of_range& e) {
2786       {
2787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2788       };
2789     } catch (std::exception& e) {
2790       {
2791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2792       };
2793     } catch (Dali::DaliException e) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2796       };
2797     } catch (...) {
2798       {
2799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2800       };
2801     }
2802   }
2803
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2810   intp *arg1 = (intp *) 0 ;
2811
2812   arg1 = (intp *)jarg1;
2813   {
2814     try {
2815       delete_intp(arg1);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2823       };
2824     } catch (Dali::DaliException e) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2827       };
2828     } catch (...) {
2829       {
2830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2831       };
2832     }
2833   }
2834
2835 }
2836
2837
2838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2839   intp *arg1 = (intp *) 0 ;
2840   int arg2 ;
2841
2842   arg1 = (intp *)jarg1;
2843   arg2 = (int)jarg2;
2844   {
2845     try {
2846       intp_assign(arg1,arg2);
2847     } catch (std::out_of_range& e) {
2848       {
2849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2850       };
2851     } catch (std::exception& e) {
2852       {
2853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2854       };
2855     } catch (Dali::DaliException e) {
2856       {
2857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2858       };
2859     } catch (...) {
2860       {
2861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2862       };
2863     }
2864   }
2865
2866 }
2867
2868
2869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2870   int jresult ;
2871   intp *arg1 = (intp *) 0 ;
2872   int result;
2873
2874   arg1 = (intp *)jarg1;
2875   {
2876     try {
2877       result = (int)intp_value(arg1);
2878     } catch (std::out_of_range& e) {
2879       {
2880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2881       };
2882     } catch (std::exception& e) {
2883       {
2884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2885       };
2886     } catch (Dali::DaliException e) {
2887       {
2888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2889       };
2890     } catch (...) {
2891       {
2892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2893       };
2894     }
2895   }
2896
2897   jresult = result;
2898   return jresult;
2899 }
2900
2901
2902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2903   void * jresult ;
2904   intp *arg1 = (intp *) 0 ;
2905   int *result = 0 ;
2906
2907   arg1 = (intp *)jarg1;
2908   {
2909     try {
2910       result = (int *)intp_cast(arg1);
2911     } catch (std::out_of_range& e) {
2912       {
2913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2914       };
2915     } catch (std::exception& e) {
2916       {
2917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2918       };
2919     } catch (Dali::DaliException e) {
2920       {
2921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2922       };
2923     } catch (...) {
2924       {
2925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2926       };
2927     }
2928   }
2929
2930   jresult = (void *)result;
2931   return jresult;
2932 }
2933
2934
2935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2936   void * jresult ;
2937   int *arg1 = (int *) 0 ;
2938   intp *result = 0 ;
2939
2940   arg1 = (int *)jarg1;
2941   {
2942     try {
2943       result = (intp *)intp_frompointer(arg1);
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (Dali::DaliException e) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962
2963   jresult = (void *)result;
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2969   void * jresult ;
2970   doublep *result = 0 ;
2971
2972   {
2973     try {
2974       result = (doublep *)new_doublep();
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2982       };
2983     } catch (Dali::DaliException e) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2986       };
2987     } catch (...) {
2988       {
2989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2990       };
2991     }
2992   }
2993
2994   jresult = (void *)result;
2995   return jresult;
2996 }
2997
2998
2999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3000   doublep *arg1 = (doublep *) 0 ;
3001
3002   arg1 = (doublep *)jarg1;
3003   {
3004     try {
3005       delete_doublep(arg1);
3006     } catch (std::out_of_range& e) {
3007       {
3008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (std::exception& e) {
3011       {
3012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3013       };
3014     } catch (Dali::DaliException e) {
3015       {
3016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3017       };
3018     } catch (...) {
3019       {
3020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3021       };
3022     }
3023   }
3024
3025 }
3026
3027
3028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3029   doublep *arg1 = (doublep *) 0 ;
3030   double arg2 ;
3031
3032   arg1 = (doublep *)jarg1;
3033   arg2 = (double)jarg2;
3034   {
3035     try {
3036       doublep_assign(arg1,arg2);
3037     } catch (std::out_of_range& e) {
3038       {
3039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3040       };
3041     } catch (std::exception& e) {
3042       {
3043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3044       };
3045     } catch (Dali::DaliException e) {
3046       {
3047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3048       };
3049     } catch (...) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3052       };
3053     }
3054   }
3055
3056 }
3057
3058
3059 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3060   double jresult ;
3061   doublep *arg1 = (doublep *) 0 ;
3062   double result;
3063
3064   arg1 = (doublep *)jarg1;
3065   {
3066     try {
3067       result = (double)doublep_value(arg1);
3068     } catch (std::out_of_range& e) {
3069       {
3070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3071       };
3072     } catch (std::exception& e) {
3073       {
3074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3075       };
3076     } catch (Dali::DaliException e) {
3077       {
3078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3079       };
3080     } catch (...) {
3081       {
3082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3083       };
3084     }
3085   }
3086
3087   jresult = result;
3088   return jresult;
3089 }
3090
3091
3092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3093   void * jresult ;
3094   doublep *arg1 = (doublep *) 0 ;
3095   double *result = 0 ;
3096
3097   arg1 = (doublep *)jarg1;
3098   {
3099     try {
3100       result = (double *)doublep_cast(arg1);
3101     } catch (std::out_of_range& e) {
3102       {
3103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3104       };
3105     } catch (std::exception& e) {
3106       {
3107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3108       };
3109     } catch (Dali::DaliException e) {
3110       {
3111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3112       };
3113     } catch (...) {
3114       {
3115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3116       };
3117     }
3118   }
3119
3120   jresult = (void *)result;
3121   return jresult;
3122 }
3123
3124
3125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3126   void * jresult ;
3127   double *arg1 = (double *) 0 ;
3128   doublep *result = 0 ;
3129
3130   arg1 = (double *)jarg1;
3131   {
3132     try {
3133       result = (doublep *)doublep_frompointer(arg1);
3134     } catch (std::out_of_range& e) {
3135       {
3136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (std::exception& e) {
3139       {
3140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3141       };
3142     } catch (Dali::DaliException e) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3145       };
3146     } catch (...) {
3147       {
3148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3149       };
3150     }
3151   }
3152
3153   jresult = (void *)result;
3154   return jresult;
3155 }
3156
3157
3158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3159   void * jresult ;
3160   uintp *result = 0 ;
3161
3162   {
3163     try {
3164       result = (uintp *)new_uintp();
3165     } catch (std::out_of_range& e) {
3166       {
3167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3168       };
3169     } catch (std::exception& e) {
3170       {
3171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3172       };
3173     } catch (Dali::DaliException e) {
3174       {
3175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3176       };
3177     } catch (...) {
3178       {
3179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3180       };
3181     }
3182   }
3183
3184   jresult = (void *)result;
3185   return jresult;
3186 }
3187
3188
3189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3190   uintp *arg1 = (uintp *) 0 ;
3191
3192   arg1 = (uintp *)jarg1;
3193   {
3194     try {
3195       delete_uintp(arg1);
3196     } catch (std::out_of_range& e) {
3197       {
3198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3199       };
3200     } catch (std::exception& e) {
3201       {
3202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3203       };
3204     } catch (Dali::DaliException e) {
3205       {
3206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3207       };
3208     } catch (...) {
3209       {
3210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3211       };
3212     }
3213   }
3214
3215 }
3216
3217
3218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3219   uintp *arg1 = (uintp *) 0 ;
3220   unsigned int arg2 ;
3221
3222   arg1 = (uintp *)jarg1;
3223   arg2 = (unsigned int)jarg2;
3224   {
3225     try {
3226       uintp_assign(arg1,arg2);
3227     } catch (std::out_of_range& e) {
3228       {
3229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3230       };
3231     } catch (std::exception& e) {
3232       {
3233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3234       };
3235     } catch (Dali::DaliException e) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3238       };
3239     } catch (...) {
3240       {
3241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3242       };
3243     }
3244   }
3245
3246 }
3247
3248
3249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3250   unsigned int jresult ;
3251   uintp *arg1 = (uintp *) 0 ;
3252   unsigned int result;
3253
3254   arg1 = (uintp *)jarg1;
3255   {
3256     try {
3257       result = (unsigned int)uintp_value(arg1);
3258     } catch (std::out_of_range& e) {
3259       {
3260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3261       };
3262     } catch (std::exception& e) {
3263       {
3264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3265       };
3266     } catch (Dali::DaliException e) {
3267       {
3268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3269       };
3270     } catch (...) {
3271       {
3272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3273       };
3274     }
3275   }
3276
3277   jresult = result;
3278   return jresult;
3279 }
3280
3281
3282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3283   void * jresult ;
3284   uintp *arg1 = (uintp *) 0 ;
3285   unsigned int *result = 0 ;
3286
3287   arg1 = (uintp *)jarg1;
3288   {
3289     try {
3290       result = (unsigned int *)uintp_cast(arg1);
3291     } catch (std::out_of_range& e) {
3292       {
3293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3294       };
3295     } catch (std::exception& e) {
3296       {
3297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3298       };
3299     } catch (Dali::DaliException e) {
3300       {
3301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3302       };
3303     } catch (...) {
3304       {
3305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3306       };
3307     }
3308   }
3309
3310   jresult = (void *)result;
3311   return jresult;
3312 }
3313
3314
3315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3316   void * jresult ;
3317   unsigned int *arg1 = (unsigned int *) 0 ;
3318   uintp *result = 0 ;
3319
3320   arg1 = (unsigned int *)jarg1;
3321   {
3322     try {
3323       result = (uintp *)uintp_frompointer(arg1);
3324     } catch (std::out_of_range& e) {
3325       {
3326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3327       };
3328     } catch (std::exception& e) {
3329       {
3330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3331       };
3332     } catch (Dali::DaliException e) {
3333       {
3334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3335       };
3336     } catch (...) {
3337       {
3338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3339       };
3340     }
3341   }
3342
3343   jresult = (void *)result;
3344   return jresult;
3345 }
3346
3347
3348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3349   void * jresult ;
3350   ushortp *result = 0 ;
3351
3352   {
3353     try {
3354       result = (ushortp *)new_ushortp();
3355     } catch (std::out_of_range& e) {
3356       {
3357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3358       };
3359     } catch (std::exception& e) {
3360       {
3361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3362       };
3363     } catch (Dali::DaliException e) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3366       };
3367     } catch (...) {
3368       {
3369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3370       };
3371     }
3372   }
3373
3374   jresult = (void *)result;
3375   return jresult;
3376 }
3377
3378
3379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3380   ushortp *arg1 = (ushortp *) 0 ;
3381
3382   arg1 = (ushortp *)jarg1;
3383   {
3384     try {
3385       delete_ushortp(arg1);
3386     } catch (std::out_of_range& e) {
3387       {
3388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (std::exception& e) {
3391       {
3392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3393       };
3394     } catch (Dali::DaliException e) {
3395       {
3396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3397       };
3398     } catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3401       };
3402     }
3403   }
3404
3405 }
3406
3407
3408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3409   ushortp *arg1 = (ushortp *) 0 ;
3410   unsigned short arg2 ;
3411
3412   arg1 = (ushortp *)jarg1;
3413   arg2 = (unsigned short)jarg2;
3414   {
3415     try {
3416       ushortp_assign(arg1,arg2);
3417     } catch (std::out_of_range& e) {
3418       {
3419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3420       };
3421     } catch (std::exception& e) {
3422       {
3423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3424       };
3425     } catch (Dali::DaliException e) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3432       };
3433     }
3434   }
3435
3436 }
3437
3438
3439 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3440   unsigned short jresult ;
3441   ushortp *arg1 = (ushortp *) 0 ;
3442   unsigned short result;
3443
3444   arg1 = (ushortp *)jarg1;
3445   {
3446     try {
3447       result = (unsigned short)ushortp_value(arg1);
3448     } catch (std::out_of_range& e) {
3449       {
3450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3451       };
3452     } catch (std::exception& e) {
3453       {
3454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3455       };
3456     } catch (Dali::DaliException e) {
3457       {
3458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3459       };
3460     } catch (...) {
3461       {
3462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3463       };
3464     }
3465   }
3466
3467   jresult = result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3473   void * jresult ;
3474   ushortp *arg1 = (ushortp *) 0 ;
3475   unsigned short *result = 0 ;
3476
3477   arg1 = (ushortp *)jarg1;
3478   {
3479     try {
3480       result = (unsigned short *)ushortp_cast(arg1);
3481     } catch (std::out_of_range& e) {
3482       {
3483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3484       };
3485     } catch (std::exception& e) {
3486       {
3487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (Dali::DaliException e) {
3490       {
3491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3492       };
3493     } catch (...) {
3494       {
3495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3496       };
3497     }
3498   }
3499
3500   jresult = (void *)result;
3501   return jresult;
3502 }
3503
3504
3505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3506   void * jresult ;
3507   unsigned short *arg1 = (unsigned short *) 0 ;
3508   ushortp *result = 0 ;
3509
3510   arg1 = (unsigned short *)jarg1;
3511   {
3512     try {
3513       result = (ushortp *)ushortp_frompointer(arg1);
3514     } catch (std::out_of_range& e) {
3515       {
3516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3517       };
3518     } catch (std::exception& e) {
3519       {
3520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3521       };
3522     } catch (Dali::DaliException e) {
3523       {
3524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3525       };
3526     } catch (...) {
3527       {
3528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3529       };
3530     }
3531   }
3532
3533   jresult = (void *)result;
3534   return jresult;
3535 }
3536
3537
3538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3539   unsigned int jresult ;
3540   int arg1 ;
3541   unsigned int result;
3542
3543   arg1 = (int)jarg1;
3544   {
3545     try {
3546       result = (unsigned int)int_to_uint(arg1);
3547     } catch (std::out_of_range& e) {
3548       {
3549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3550       };
3551     } catch (std::exception& e) {
3552       {
3553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3554       };
3555     } catch (Dali::DaliException e) {
3556       {
3557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3558       };
3559     } catch (...) {
3560       {
3561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3562       };
3563     }
3564   }
3565
3566   jresult = result;
3567   return jresult;
3568 }
3569
3570
3571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3572   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3573
3574   arg1 = (Dali::RefObject *)jarg1;
3575   {
3576     try {
3577       (arg1)->Reference();
3578     } catch (std::out_of_range& e) {
3579       {
3580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3581       };
3582     } catch (std::exception& e) {
3583       {
3584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3585       };
3586     } catch (Dali::DaliException e) {
3587       {
3588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3589       };
3590     } catch (...) {
3591       {
3592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3593       };
3594     }
3595   }
3596
3597 }
3598
3599
3600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3601   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3602
3603   arg1 = (Dali::RefObject *)jarg1;
3604   {
3605     try {
3606       (arg1)->Unreference();
3607     } catch (std::out_of_range& e) {
3608       {
3609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3610       };
3611     } catch (std::exception& e) {
3612       {
3613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3614       };
3615     } catch (Dali::DaliException e) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3618       };
3619     } catch (...) {
3620       {
3621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3622       };
3623     }
3624   }
3625
3626 }
3627
3628
3629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3630   int jresult ;
3631   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3632   int result;
3633
3634   arg1 = (Dali::RefObject *)jarg1;
3635   {
3636     try {
3637       result = (int)(arg1)->ReferenceCount();
3638     } catch (std::out_of_range& e) {
3639       {
3640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3641       };
3642     } catch (std::exception& e) {
3643       {
3644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3645       };
3646     } catch (Dali::DaliException e) {
3647       {
3648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3649       };
3650     } catch (...) {
3651       {
3652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3653       };
3654     }
3655   }
3656
3657   jresult = result;
3658   return jresult;
3659 }
3660
3661
3662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3663   void * jresult ;
3664   Dali::Any *result = 0 ;
3665
3666   {
3667     try {
3668       result = (Dali::Any *)new Dali::Any();
3669     } catch (std::out_of_range& e) {
3670       {
3671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3672       };
3673     } catch (std::exception& e) {
3674       {
3675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3676       };
3677     } catch (Dali::DaliException e) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3680       };
3681     } catch (...) {
3682       {
3683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3684       };
3685     }
3686   }
3687
3688   jresult = (void *)result;
3689   return jresult;
3690 }
3691
3692
3693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3694   Dali::Any *arg1 = (Dali::Any *) 0 ;
3695
3696   arg1 = (Dali::Any *)jarg1;
3697   {
3698     try {
3699       delete arg1;
3700     } catch (std::out_of_range& e) {
3701       {
3702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3703       };
3704     } catch (std::exception& e) {
3705       {
3706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3707       };
3708     } catch (Dali::DaliException e) {
3709       {
3710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3711       };
3712     } catch (...) {
3713       {
3714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3715       };
3716     }
3717   }
3718
3719 }
3720
3721
3722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3723   char *arg1 = (char *) 0 ;
3724
3725   arg1 = (char *)jarg1;
3726   {
3727     try {
3728       Dali::Any::AssertAlways((char const *)arg1);
3729     } catch (std::out_of_range& e) {
3730       {
3731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3732       };
3733     } catch (std::exception& e) {
3734       {
3735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3736       };
3737     } catch (Dali::DaliException e) {
3738       {
3739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3740       };
3741     } catch (...) {
3742       {
3743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3744       };
3745     }
3746   }
3747
3748 }
3749
3750
3751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3752   void * jresult ;
3753   Dali::Any *arg1 = 0 ;
3754   Dali::Any *result = 0 ;
3755
3756   arg1 = (Dali::Any *)jarg1;
3757   if (!arg1) {
3758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3759     return 0;
3760   }
3761   {
3762     try {
3763       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3764     } catch (std::out_of_range& e) {
3765       {
3766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3767       };
3768     } catch (std::exception& e) {
3769       {
3770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3771       };
3772     } catch (Dali::DaliException e) {
3773       {
3774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3775       };
3776     } catch (...) {
3777       {
3778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3779       };
3780     }
3781   }
3782
3783   jresult = (void *)result;
3784   return jresult;
3785 }
3786
3787
3788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3789   void * jresult ;
3790   Dali::Any *arg1 = (Dali::Any *) 0 ;
3791   Dali::Any *arg2 = 0 ;
3792   Dali::Any *result = 0 ;
3793
3794   arg1 = (Dali::Any *)jarg1;
3795   arg2 = (Dali::Any *)jarg2;
3796   if (!arg2) {
3797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3798     return 0;
3799   }
3800   {
3801     try {
3802       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3803     } catch (std::out_of_range& e) {
3804       {
3805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3806       };
3807     } catch (std::exception& e) {
3808       {
3809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3810       };
3811     } catch (Dali::DaliException e) {
3812       {
3813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3814       };
3815     } catch (...) {
3816       {
3817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3818       };
3819     }
3820   }
3821
3822   jresult = (void *)result;
3823   return jresult;
3824 }
3825
3826
3827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3828   void * jresult ;
3829   Dali::Any *arg1 = (Dali::Any *) 0 ;
3830   std::type_info *result = 0 ;
3831
3832   arg1 = (Dali::Any *)jarg1;
3833   {
3834     try {
3835       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3836     } catch (std::out_of_range& e) {
3837       {
3838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3839       };
3840     } catch (std::exception& e) {
3841       {
3842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3843       };
3844     } catch (Dali::DaliException e) {
3845       {
3846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3847       };
3848     } catch (...) {
3849       {
3850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3851       };
3852     }
3853   }
3854
3855   jresult = (void *)result;
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3861   unsigned int jresult ;
3862   Dali::Any *arg1 = (Dali::Any *) 0 ;
3863   bool result;
3864
3865   arg1 = (Dali::Any *)jarg1;
3866   {
3867     try {
3868       result = (bool)((Dali::Any const *)arg1)->Empty();
3869     } catch (std::out_of_range& e) {
3870       {
3871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (std::exception& e) {
3874       {
3875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3876       };
3877     } catch (Dali::DaliException e) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3880       };
3881     } catch (...) {
3882       {
3883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3884       };
3885     }
3886   }
3887
3888   jresult = result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3894   void * jresult ;
3895   std::type_info *arg1 = 0 ;
3896   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3897   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3898   Dali::Any::AnyContainerBase *result = 0 ;
3899
3900   arg1 = (std::type_info *)jarg1;
3901   if (!arg1) {
3902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3903     return 0;
3904   }
3905   arg2 = (Dali::Any::CloneFunc)jarg2;
3906   arg3 = (Dali::Any::DeleteFunc)jarg3;
3907   {
3908     try {
3909       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3910     } catch (std::out_of_range& e) {
3911       {
3912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3913       };
3914     } catch (std::exception& e) {
3915       {
3916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3917       };
3918     } catch (Dali::DaliException e) {
3919       {
3920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3921       };
3922     } catch (...) {
3923       {
3924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3925       };
3926     }
3927   }
3928
3929   jresult = (void *)result;
3930   return jresult;
3931 }
3932
3933
3934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3935   void * jresult ;
3936   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3937   std::type_info *result = 0 ;
3938
3939   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3940   {
3941     try {
3942       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3943     } catch (std::out_of_range& e) {
3944       {
3945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3946       };
3947     } catch (std::exception& e) {
3948       {
3949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3950       };
3951     } catch (Dali::DaliException e) {
3952       {
3953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3954       };
3955     } catch (...) {
3956       {
3957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3958       };
3959     }
3960   }
3961
3962   jresult = (void *)result;
3963   return jresult;
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3968   void * jresult ;
3969   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3970   ::std::type_info *result = 0 ;
3971
3972   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3973   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3974   jresult = (void *)result;
3975   return jresult;
3976 }
3977
3978
3979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3980   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3981   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3982
3983   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3984   arg2 = (Dali::Any::CloneFunc)jarg2;
3985   if (arg1) (arg1)->mCloneFunc = arg2;
3986 }
3987
3988
3989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3990   void * jresult ;
3991   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3992   Dali::Any::CloneFunc result;
3993
3994   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3995   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3996   jresult = (void *)result;
3997   return jresult;
3998 }
3999
4000
4001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4002   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4003   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4004
4005   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4006   arg2 = (Dali::Any::DeleteFunc)jarg2;
4007   if (arg1) (arg1)->mDeleteFunc = arg2;
4008 }
4009
4010
4011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4012   void * jresult ;
4013   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4014   Dali::Any::DeleteFunc result;
4015
4016   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4017   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4018   jresult = (void *)result;
4019   return jresult;
4020 }
4021
4022
4023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4024   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4025
4026   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4027   {
4028     try {
4029       delete arg1;
4030     } catch (std::out_of_range& e) {
4031       {
4032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4033       };
4034     } catch (std::exception& e) {
4035       {
4036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4037       };
4038     } catch (Dali::DaliException e) {
4039       {
4040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4041       };
4042     } catch (...) {
4043       {
4044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4045       };
4046     }
4047   }
4048
4049 }
4050
4051
4052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4053   Dali::Any *arg1 = (Dali::Any *) 0 ;
4054   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4055
4056   arg1 = (Dali::Any *)jarg1;
4057   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4058   if (arg1) (arg1)->mContainer = arg2;
4059 }
4060
4061
4062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4063   void * jresult ;
4064   Dali::Any *arg1 = (Dali::Any *) 0 ;
4065   Dali::Any::AnyContainerBase *result = 0 ;
4066
4067   arg1 = (Dali::Any *)jarg1;
4068   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4069   jresult = (void *)result;
4070   return jresult;
4071 }
4072
4073
4074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4075   char *arg1 = (char *) 0 ;
4076   char *arg2 = (char *) 0 ;
4077
4078   arg1 = (char *)jarg1;
4079   arg2 = (char *)jarg2;
4080   {
4081     try {
4082       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4083     } catch (std::out_of_range& e) {
4084       {
4085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4086       };
4087     } catch (std::exception& e) {
4088       {
4089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4090       };
4091     } catch (Dali::DaliException e) {
4092       {
4093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4094       };
4095     } catch (...) {
4096       {
4097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4098       };
4099     }
4100   }
4101
4102 }
4103
4104
4105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4106   void * jresult ;
4107   char *arg1 = (char *) 0 ;
4108   char *arg2 = (char *) 0 ;
4109   Dali::DaliException *result = 0 ;
4110
4111   arg1 = (char *)jarg1;
4112   arg2 = (char *)jarg2;
4113   {
4114     try {
4115       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4116     } catch (std::out_of_range& e) {
4117       {
4118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4119       };
4120     } catch (std::exception& e) {
4121       {
4122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4123       };
4124     } catch (Dali::DaliException e) {
4125       {
4126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4127       };
4128     } catch (...) {
4129       {
4130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4131       };
4132     }
4133   }
4134
4135   jresult = (void *)result;
4136   return jresult;
4137 }
4138
4139
4140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4141   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4142   std::string arg2 = std::string(jarg2);
4143
4144   arg1 = (Dali::DaliException *)jarg1;
4145   {
4146     if (!arg2.empty()) {
4147       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4148     } else {
4149       arg1->location = 0;
4150     }
4151   }
4152 }
4153
4154 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4155   char * jresult ;
4156   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4157   char *result = 0 ;
4158
4159   arg1 = (Dali::DaliException *)jarg1;
4160   result = (char *) ((arg1)->location);
4161   jresult = SWIG_csharp_string_callback((const char *)result);
4162   return jresult;
4163 }
4164
4165
4166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4167   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4168   std::string arg2 = std::string(jarg2);
4169
4170   arg1 = (Dali::DaliException *)jarg1;
4171   {
4172     if (!arg2.empty()) {
4173       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4174     } else {
4175       arg1->condition = 0;
4176     }
4177   }
4178 }
4179
4180
4181 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4182   char * jresult ;
4183   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4184   char *result = 0 ;
4185
4186   arg1 = (Dali::DaliException *)jarg1;
4187   result = (char *) ((arg1)->condition);
4188   jresult = SWIG_csharp_string_callback((const char *)result);
4189   return jresult;
4190 }
4191
4192
4193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4194   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4195
4196   arg1 = (Dali::DaliException *)jarg1;
4197   {
4198     try {
4199       delete arg1;
4200     } catch (std::out_of_range& e) {
4201       {
4202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4203       };
4204     } catch (std::exception& e) {
4205       {
4206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4207       };
4208     } catch (Dali::DaliException e) {
4209       {
4210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4211       };
4212     } catch (...) {
4213       {
4214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4215       };
4216     }
4217   }
4218
4219 }
4220
4221
4222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4223   void * jresult ;
4224   Dali::Vector2 *result = 0 ;
4225
4226   {
4227     try {
4228       result = (Dali::Vector2 *)new Dali::Vector2();
4229     } catch (std::out_of_range& e) {
4230       {
4231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4232       };
4233     } catch (std::exception& e) {
4234       {
4235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (Dali::DaliException e) {
4238       {
4239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4240       };
4241     } catch (...) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4244       };
4245     }
4246   }
4247
4248   jresult = (void *)result;
4249   return jresult;
4250 }
4251
4252
4253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4254   void * jresult ;
4255   float arg1 ;
4256   float arg2 ;
4257   Dali::Vector2 *result = 0 ;
4258
4259   arg1 = (float)jarg1;
4260   arg2 = (float)jarg2;
4261   {
4262     try {
4263       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4264     } catch (std::out_of_range& e) {
4265       {
4266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (std::exception& e) {
4269       {
4270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4271       };
4272     } catch (Dali::DaliException e) {
4273       {
4274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4275       };
4276     } catch (...) {
4277       {
4278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4279       };
4280     }
4281   }
4282
4283   jresult = (void *)result;
4284   return jresult;
4285 }
4286
4287
4288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4289   void * jresult ;
4290   float *arg1 = (float *) 0 ;
4291   Dali::Vector2 *result = 0 ;
4292
4293   arg1 = jarg1;
4294   {
4295     try {
4296       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4297     } catch (std::out_of_range& e) {
4298       {
4299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4300       };
4301     } catch (std::exception& e) {
4302       {
4303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4304       };
4305     } catch (Dali::DaliException e) {
4306       {
4307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4308       };
4309     } catch (...) {
4310       {
4311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4312       };
4313     }
4314   }
4315
4316   jresult = (void *)result;
4317
4318
4319   return jresult;
4320 }
4321
4322
4323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4324   void * jresult ;
4325   Dali::Vector3 *arg1 = 0 ;
4326   Dali::Vector2 *result = 0 ;
4327
4328   arg1 = (Dali::Vector3 *)jarg1;
4329   if (!arg1) {
4330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4331     return 0;
4332   }
4333   {
4334     try {
4335       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4336     } catch (std::out_of_range& e) {
4337       {
4338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4339       };
4340     } catch (std::exception& e) {
4341       {
4342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4343       };
4344     } catch (Dali::DaliException e) {
4345       {
4346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4347       };
4348     } catch (...) {
4349       {
4350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4351       };
4352     }
4353   }
4354
4355   jresult = (void *)result;
4356   return jresult;
4357 }
4358
4359
4360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4361   void * jresult ;
4362   Dali::Vector4 *arg1 = 0 ;
4363   Dali::Vector2 *result = 0 ;
4364
4365   arg1 = (Dali::Vector4 *)jarg1;
4366   if (!arg1) {
4367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4368     return 0;
4369   }
4370   {
4371     try {
4372       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4373     } catch (std::out_of_range& e) {
4374       {
4375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4376       };
4377     } catch (std::exception& e) {
4378       {
4379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4380       };
4381     } catch (Dali::DaliException e) {
4382       {
4383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4384       };
4385     } catch (...) {
4386       {
4387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4388       };
4389     }
4390   }
4391
4392   jresult = (void *)result;
4393   return jresult;
4394 }
4395
4396
4397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4398   void * jresult ;
4399   Dali::Vector2 *result = 0 ;
4400
4401   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4402   jresult = (void *)result;
4403   return jresult;
4404 }
4405
4406
4407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4408   void * jresult ;
4409   Dali::Vector2 *result = 0 ;
4410
4411   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4412   jresult = (void *)result;
4413   return jresult;
4414 }
4415
4416
4417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4418   void * jresult ;
4419   Dali::Vector2 *result = 0 ;
4420
4421   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4422   jresult = (void *)result;
4423   return jresult;
4424 }
4425
4426
4427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4428   void * jresult ;
4429   Dali::Vector2 *result = 0 ;
4430
4431   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4432   jresult = (void *)result;
4433   return jresult;
4434 }
4435
4436
4437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4438   void * jresult ;
4439   Dali::Vector2 *result = 0 ;
4440
4441   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4442   jresult = (void *)result;
4443   return jresult;
4444 }
4445
4446
4447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4448   void * jresult ;
4449   Dali::Vector2 *result = 0 ;
4450
4451   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4452   jresult = (void *)result;
4453   return jresult;
4454 }
4455
4456
4457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4458   void * jresult ;
4459   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4460   float *arg2 = (float *) 0 ;
4461   Dali::Vector2 *result = 0 ;
4462
4463   arg1 = (Dali::Vector2 *)jarg1;
4464   arg2 = jarg2;
4465   {
4466     try {
4467       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4468     } catch (std::out_of_range& e) {
4469       {
4470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (std::exception& e) {
4473       {
4474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4475       };
4476     } catch (Dali::DaliException e) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4479       };
4480     } catch (...) {
4481       {
4482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4483       };
4484     }
4485   }
4486
4487   jresult = (void *)result;
4488
4489
4490   return jresult;
4491 }
4492
4493
4494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4495   void * jresult ;
4496   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4497   Dali::Vector3 *arg2 = 0 ;
4498   Dali::Vector2 *result = 0 ;
4499
4500   arg1 = (Dali::Vector2 *)jarg1;
4501   arg2 = (Dali::Vector3 *)jarg2;
4502   if (!arg2) {
4503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4504     return 0;
4505   }
4506   {
4507     try {
4508       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4509     } catch (std::out_of_range& e) {
4510       {
4511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4512       };
4513     } catch (std::exception& e) {
4514       {
4515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4516       };
4517     } catch (Dali::DaliException e) {
4518       {
4519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4520       };
4521     } catch (...) {
4522       {
4523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4524       };
4525     }
4526   }
4527
4528   jresult = (void *)result;
4529   return jresult;
4530 }
4531
4532
4533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4534   void * jresult ;
4535   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4536   Dali::Vector4 *arg2 = 0 ;
4537   Dali::Vector2 *result = 0 ;
4538
4539   arg1 = (Dali::Vector2 *)jarg1;
4540   arg2 = (Dali::Vector4 *)jarg2;
4541   if (!arg2) {
4542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4543     return 0;
4544   }
4545   {
4546     try {
4547       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4548     } catch (std::out_of_range& e) {
4549       {
4550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4551       };
4552     } catch (std::exception& e) {
4553       {
4554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4555       };
4556     } catch (Dali::DaliException e) {
4557       {
4558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4559       };
4560     } catch (...) {
4561       {
4562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4563       };
4564     }
4565   }
4566
4567   jresult = (void *)result;
4568   return jresult;
4569 }
4570
4571
4572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4573   void * jresult ;
4574   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4575   Dali::Vector2 *arg2 = 0 ;
4576   Dali::Vector2 result;
4577
4578   arg1 = (Dali::Vector2 *)jarg1;
4579   arg2 = (Dali::Vector2 *)jarg2;
4580   if (!arg2) {
4581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4582     return 0;
4583   }
4584   {
4585     try {
4586       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4587     } catch (std::out_of_range& e) {
4588       {
4589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4590       };
4591     } catch (std::exception& e) {
4592       {
4593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4594       };
4595     } catch (Dali::DaliException e) {
4596       {
4597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4598       };
4599     } catch (...) {
4600       {
4601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4602       };
4603     }
4604   }
4605
4606   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4607   return jresult;
4608 }
4609
4610
4611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4612   void * jresult ;
4613   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4614   Dali::Vector2 *arg2 = 0 ;
4615   Dali::Vector2 *result = 0 ;
4616
4617   arg1 = (Dali::Vector2 *)jarg1;
4618   arg2 = (Dali::Vector2 *)jarg2;
4619   if (!arg2) {
4620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4621     return 0;
4622   }
4623   {
4624     try {
4625       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4626     } catch (std::out_of_range& e) {
4627       {
4628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4629       };
4630     } catch (std::exception& e) {
4631       {
4632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4633       };
4634     } catch (Dali::DaliException e) {
4635       {
4636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4637       };
4638     } catch (...) {
4639       {
4640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4641       };
4642     }
4643   }
4644
4645   jresult = (void *)result;
4646   return jresult;
4647 }
4648
4649
4650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4651   void * jresult ;
4652   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4653   Dali::Vector2 *arg2 = 0 ;
4654   Dali::Vector2 result;
4655
4656   arg1 = (Dali::Vector2 *)jarg1;
4657   arg2 = (Dali::Vector2 *)jarg2;
4658   if (!arg2) {
4659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4660     return 0;
4661   }
4662   {
4663     try {
4664       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4665     } catch (std::out_of_range& e) {
4666       {
4667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4668       };
4669     } catch (std::exception& e) {
4670       {
4671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4672       };
4673     } catch (Dali::DaliException e) {
4674       {
4675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4676       };
4677     } catch (...) {
4678       {
4679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4680       };
4681     }
4682   }
4683
4684   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4685   return jresult;
4686 }
4687
4688
4689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4690   void * jresult ;
4691   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4692   Dali::Vector2 *arg2 = 0 ;
4693   Dali::Vector2 *result = 0 ;
4694
4695   arg1 = (Dali::Vector2 *)jarg1;
4696   arg2 = (Dali::Vector2 *)jarg2;
4697   if (!arg2) {
4698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4699     return 0;
4700   }
4701   {
4702     try {
4703       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4704     } catch (std::out_of_range& e) {
4705       {
4706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (std::exception& e) {
4709       {
4710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4711       };
4712     } catch (Dali::DaliException e) {
4713       {
4714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4715       };
4716     } catch (...) {
4717       {
4718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4719       };
4720     }
4721   }
4722
4723   jresult = (void *)result;
4724   return jresult;
4725 }
4726
4727
4728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4729   void * jresult ;
4730   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4731   Dali::Vector2 *arg2 = 0 ;
4732   Dali::Vector2 result;
4733
4734   arg1 = (Dali::Vector2 *)jarg1;
4735   arg2 = (Dali::Vector2 *)jarg2;
4736   if (!arg2) {
4737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4738     return 0;
4739   }
4740   {
4741     try {
4742       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4743     } catch (std::out_of_range& e) {
4744       {
4745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4746       };
4747     } catch (std::exception& e) {
4748       {
4749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4750       };
4751     } catch (Dali::DaliException e) {
4752       {
4753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4754       };
4755     } catch (...) {
4756       {
4757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4758       };
4759     }
4760   }
4761
4762   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4763   return jresult;
4764 }
4765
4766
4767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4768   void * jresult ;
4769   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4770   float arg2 ;
4771   Dali::Vector2 result;
4772
4773   arg1 = (Dali::Vector2 *)jarg1;
4774   arg2 = (float)jarg2;
4775   {
4776     try {
4777       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4778     } catch (std::out_of_range& e) {
4779       {
4780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4781       };
4782     } catch (std::exception& e) {
4783       {
4784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4785       };
4786     } catch (Dali::DaliException e) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4789       };
4790     } catch (...) {
4791       {
4792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4793       };
4794     }
4795   }
4796
4797   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4798   return jresult;
4799 }
4800
4801
4802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4803   void * jresult ;
4804   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4805   Dali::Vector2 *arg2 = 0 ;
4806   Dali::Vector2 *result = 0 ;
4807
4808   arg1 = (Dali::Vector2 *)jarg1;
4809   arg2 = (Dali::Vector2 *)jarg2;
4810   if (!arg2) {
4811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4812     return 0;
4813   }
4814   {
4815     try {
4816       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4817     } catch (std::out_of_range& e) {
4818       {
4819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4820       };
4821     } catch (std::exception& e) {
4822       {
4823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4824       };
4825     } catch (Dali::DaliException e) {
4826       {
4827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4828       };
4829     } catch (...) {
4830       {
4831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4832       };
4833     }
4834   }
4835
4836   jresult = (void *)result;
4837   return jresult;
4838 }
4839
4840
4841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4842   void * jresult ;
4843   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4844   float arg2 ;
4845   Dali::Vector2 *result = 0 ;
4846
4847   arg1 = (Dali::Vector2 *)jarg1;
4848   arg2 = (float)jarg2;
4849   {
4850     try {
4851       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4852     } catch (std::out_of_range& e) {
4853       {
4854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4855       };
4856     } catch (std::exception& e) {
4857       {
4858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4859       };
4860     } catch (Dali::DaliException e) {
4861       {
4862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4863       };
4864     } catch (...) {
4865       {
4866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4867       };
4868     }
4869   }
4870
4871   jresult = (void *)result;
4872   return jresult;
4873 }
4874
4875
4876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4877   void * jresult ;
4878   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4879   Dali::Vector2 *arg2 = 0 ;
4880   Dali::Vector2 result;
4881
4882   arg1 = (Dali::Vector2 *)jarg1;
4883   arg2 = (Dali::Vector2 *)jarg2;
4884   if (!arg2) {
4885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4886     return 0;
4887   }
4888   {
4889     try {
4890       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4891     } catch (std::out_of_range& e) {
4892       {
4893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4894       };
4895     } catch (std::exception& e) {
4896       {
4897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4898       };
4899     } catch (Dali::DaliException e) {
4900       {
4901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4902       };
4903     } catch (...) {
4904       {
4905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4906       };
4907     }
4908   }
4909
4910   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4911   return jresult;
4912 }
4913
4914
4915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4916   void * jresult ;
4917   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4918   float arg2 ;
4919   Dali::Vector2 result;
4920
4921   arg1 = (Dali::Vector2 *)jarg1;
4922   arg2 = (float)jarg2;
4923   {
4924     try {
4925       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4926     } catch (std::out_of_range& e) {
4927       {
4928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4929       };
4930     } catch (std::exception& e) {
4931       {
4932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4933       };
4934     } catch (Dali::DaliException e) {
4935       {
4936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4937       };
4938     } catch (...) {
4939       {
4940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4941       };
4942     }
4943   }
4944
4945   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4946   return jresult;
4947 }
4948
4949
4950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4951   void * jresult ;
4952   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4953   Dali::Vector2 *arg2 = 0 ;
4954   Dali::Vector2 *result = 0 ;
4955
4956   arg1 = (Dali::Vector2 *)jarg1;
4957   arg2 = (Dali::Vector2 *)jarg2;
4958   if (!arg2) {
4959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4960     return 0;
4961   }
4962   {
4963     try {
4964       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4965     } catch (std::out_of_range& e) {
4966       {
4967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4968       };
4969     } catch (std::exception& e) {
4970       {
4971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4972       };
4973     } catch (Dali::DaliException e) {
4974       {
4975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4976       };
4977     } catch (...) {
4978       {
4979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4980       };
4981     }
4982   }
4983
4984   jresult = (void *)result;
4985   return jresult;
4986 }
4987
4988
4989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4990   void * jresult ;
4991   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4992   float arg2 ;
4993   Dali::Vector2 *result = 0 ;
4994
4995   arg1 = (Dali::Vector2 *)jarg1;
4996   arg2 = (float)jarg2;
4997   {
4998     try {
4999       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5000     } catch (std::out_of_range& e) {
5001       {
5002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5003       };
5004     } catch (std::exception& e) {
5005       {
5006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5007       };
5008     } catch (Dali::DaliException e) {
5009       {
5010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5011       };
5012     } catch (...) {
5013       {
5014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5015       };
5016     }
5017   }
5018
5019   jresult = (void *)result;
5020   return jresult;
5021 }
5022
5023
5024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5025   void * jresult ;
5026   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5027   Dali::Vector2 result;
5028
5029   arg1 = (Dali::Vector2 *)jarg1;
5030   {
5031     try {
5032       result = ((Dali::Vector2 const *)arg1)->operator -();
5033     } catch (std::out_of_range& e) {
5034       {
5035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5036       };
5037     } catch (std::exception& e) {
5038       {
5039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5040       };
5041     } catch (Dali::DaliException e) {
5042       {
5043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5044       };
5045     } catch (...) {
5046       {
5047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5048       };
5049     }
5050   }
5051
5052   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5053   return jresult;
5054 }
5055
5056
5057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5058   unsigned int jresult ;
5059   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5060   Dali::Vector2 *arg2 = 0 ;
5061   bool result;
5062
5063   arg1 = (Dali::Vector2 *)jarg1;
5064   arg2 = (Dali::Vector2 *)jarg2;
5065   if (!arg2) {
5066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5067     return 0;
5068   }
5069   {
5070     try {
5071       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5072     } catch (std::out_of_range& e) {
5073       {
5074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (std::exception& e) {
5077       {
5078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5079       };
5080     } catch (Dali::DaliException e) {
5081       {
5082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5083       };
5084     } catch (...) {
5085       {
5086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5087       };
5088     }
5089   }
5090
5091   jresult = result;
5092   return jresult;
5093 }
5094
5095
5096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5097   unsigned int jresult ;
5098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5099   Dali::Vector2 *arg2 = 0 ;
5100   bool result;
5101
5102   arg1 = (Dali::Vector2 *)jarg1;
5103   arg2 = (Dali::Vector2 *)jarg2;
5104   if (!arg2) {
5105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5106     return 0;
5107   }
5108   {
5109     try {
5110       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5111     } catch (std::out_of_range& e) {
5112       {
5113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5114       };
5115     } catch (std::exception& e) {
5116       {
5117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5118       };
5119     } catch (Dali::DaliException e) {
5120       {
5121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5122       };
5123     } catch (...) {
5124       {
5125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5126       };
5127     }
5128   }
5129
5130   jresult = result;
5131   return jresult;
5132 }
5133
5134
5135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5136   float jresult ;
5137   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5138   unsigned int arg2 ;
5139   float *result = 0 ;
5140
5141   arg1 = (Dali::Vector2 *)jarg1;
5142   arg2 = (unsigned int)jarg2;
5143   {
5144     try {
5145       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5146     } catch (std::out_of_range& e) {
5147       {
5148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5149       };
5150     } catch (std::exception& e) {
5151       {
5152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5153       };
5154     } catch (Dali::DaliException e) {
5155       {
5156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5157       };
5158     } catch (...) {
5159       {
5160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5161       };
5162     }
5163   }
5164
5165   jresult = *result;
5166   return jresult;
5167 }
5168
5169
5170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5171   float jresult ;
5172   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5173   float result;
5174
5175   arg1 = (Dali::Vector2 *)jarg1;
5176   {
5177     try {
5178       result = (float)((Dali::Vector2 const *)arg1)->Length();
5179     } catch (std::out_of_range& e) {
5180       {
5181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5182       };
5183     } catch (std::exception& e) {
5184       {
5185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5186       };
5187     } catch (Dali::DaliException e) {
5188       {
5189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5190       };
5191     } catch (...) {
5192       {
5193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5194       };
5195     }
5196   }
5197
5198   jresult = result;
5199   return jresult;
5200 }
5201
5202
5203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5204   float jresult ;
5205   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5206   float result;
5207
5208   arg1 = (Dali::Vector2 *)jarg1;
5209   {
5210     try {
5211       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5212     } catch (std::out_of_range& e) {
5213       {
5214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5215       };
5216     } catch (std::exception& e) {
5217       {
5218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5219       };
5220     } catch (Dali::DaliException e) {
5221       {
5222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5223       };
5224     } catch (...) {
5225       {
5226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5227       };
5228     }
5229   }
5230
5231   jresult = result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5237   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5238
5239   arg1 = (Dali::Vector2 *)jarg1;
5240   {
5241     try {
5242       (arg1)->Normalize();
5243     } catch (std::out_of_range& e) {
5244       {
5245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5246       };
5247     } catch (std::exception& e) {
5248       {
5249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5250       };
5251     } catch (Dali::DaliException e) {
5252       {
5253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5254       };
5255     } catch (...) {
5256       {
5257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5258       };
5259     }
5260   }
5261
5262 }
5263
5264
5265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5266   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5267   Dali::Vector2 *arg2 = 0 ;
5268   Dali::Vector2 *arg3 = 0 ;
5269
5270   arg1 = (Dali::Vector2 *)jarg1;
5271   arg2 = (Dali::Vector2 *)jarg2;
5272   if (!arg2) {
5273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5274     return ;
5275   }
5276   arg3 = (Dali::Vector2 *)jarg3;
5277   if (!arg3) {
5278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5279     return ;
5280   }
5281   {
5282     try {
5283       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5284     } catch (std::out_of_range& e) {
5285       {
5286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5287       };
5288     } catch (std::exception& e) {
5289       {
5290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5291       };
5292     } catch (Dali::DaliException e) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5295       };
5296     } catch (...) {
5297       {
5298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5299       };
5300     }
5301   }
5302
5303 }
5304
5305
5306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5307   void * jresult ;
5308   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5309   float *result = 0 ;
5310
5311   arg1 = (Dali::Vector2 *)jarg1;
5312   {
5313     try {
5314       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5315     } catch (std::out_of_range& e) {
5316       {
5317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5318       };
5319     } catch (std::exception& e) {
5320       {
5321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5322       };
5323     } catch (Dali::DaliException e) {
5324       {
5325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5326       };
5327     } catch (...) {
5328       {
5329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5330       };
5331     }
5332   }
5333
5334   jresult = (void *)result;
5335   return jresult;
5336 }
5337
5338
5339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5340   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5341   float arg2 ;
5342
5343   arg1 = (Dali::Vector2 *)jarg1;
5344   arg2 = (float)jarg2;
5345   if (arg1) (arg1)->x = arg2;
5346 }
5347
5348
5349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5350   float jresult ;
5351   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5352   float result;
5353
5354   arg1 = (Dali::Vector2 *)jarg1;
5355   result = (float) ((arg1)->x);
5356   jresult = result;
5357   return jresult;
5358 }
5359
5360
5361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5363   float arg2 ;
5364
5365   arg1 = (Dali::Vector2 *)jarg1;
5366   arg2 = (float)jarg2;
5367   if (arg1) (arg1)->width = arg2;
5368 }
5369
5370
5371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5372   float jresult ;
5373   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5374   float result;
5375
5376   arg1 = (Dali::Vector2 *)jarg1;
5377   result = (float) ((arg1)->width);
5378   jresult = result;
5379   return jresult;
5380 }
5381
5382
5383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5384   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5385   float arg2 ;
5386
5387   arg1 = (Dali::Vector2 *)jarg1;
5388   arg2 = (float)jarg2;
5389   if (arg1) (arg1)->y = arg2;
5390 }
5391
5392
5393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5394   float jresult ;
5395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5396   float result;
5397
5398   arg1 = (Dali::Vector2 *)jarg1;
5399   result = (float) ((arg1)->y);
5400   jresult = result;
5401   return jresult;
5402 }
5403
5404
5405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5406   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5407   float arg2 ;
5408
5409   arg1 = (Dali::Vector2 *)jarg1;
5410   arg2 = (float)jarg2;
5411   if (arg1) (arg1)->height = arg2;
5412 }
5413
5414
5415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5416   float jresult ;
5417   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5418   float result;
5419
5420   arg1 = (Dali::Vector2 *)jarg1;
5421   result = (float) ((arg1)->height);
5422   jresult = result;
5423   return jresult;
5424 }
5425
5426
5427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5428   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5429
5430   arg1 = (Dali::Vector2 *)jarg1;
5431   {
5432     try {
5433       delete arg1;
5434     } catch (std::out_of_range& e) {
5435       {
5436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5437       };
5438     } catch (std::exception& e) {
5439       {
5440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5441       };
5442     } catch (Dali::DaliException e) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5445       };
5446     } catch (...) {
5447       {
5448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5449       };
5450     }
5451   }
5452
5453 }
5454
5455
5456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5457   void * jresult ;
5458   Dali::Vector2 *arg1 = 0 ;
5459   Dali::Vector2 *arg2 = 0 ;
5460   Dali::Vector2 result;
5461
5462   arg1 = (Dali::Vector2 *)jarg1;
5463   if (!arg1) {
5464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5465     return 0;
5466   }
5467   arg2 = (Dali::Vector2 *)jarg2;
5468   if (!arg2) {
5469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5470     return 0;
5471   }
5472   {
5473     try {
5474       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5475     } catch (std::out_of_range& e) {
5476       {
5477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5478       };
5479     } catch (std::exception& e) {
5480       {
5481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5482       };
5483     } catch (Dali::DaliException e) {
5484       {
5485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5486       };
5487     } catch (...) {
5488       {
5489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5490       };
5491     }
5492   }
5493
5494   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5495   return jresult;
5496 }
5497
5498
5499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5500   void * jresult ;
5501   Dali::Vector2 *arg1 = 0 ;
5502   Dali::Vector2 *arg2 = 0 ;
5503   Dali::Vector2 result;
5504
5505   arg1 = (Dali::Vector2 *)jarg1;
5506   if (!arg1) {
5507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5508     return 0;
5509   }
5510   arg2 = (Dali::Vector2 *)jarg2;
5511   if (!arg2) {
5512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5513     return 0;
5514   }
5515   {
5516     try {
5517       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5518     } catch (std::out_of_range& e) {
5519       {
5520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (std::exception& e) {
5523       {
5524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5525       };
5526     } catch (Dali::DaliException e) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5529       };
5530     } catch (...) {
5531       {
5532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5533       };
5534     }
5535   }
5536
5537   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5538   return jresult;
5539 }
5540
5541
5542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5543   void * jresult ;
5544   Dali::Vector2 *arg1 = 0 ;
5545   float *arg2 = 0 ;
5546   float *arg3 = 0 ;
5547   float temp2 ;
5548   float temp3 ;
5549   Dali::Vector2 result;
5550
5551   arg1 = (Dali::Vector2 *)jarg1;
5552   if (!arg1) {
5553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5554     return 0;
5555   }
5556   temp2 = (float)jarg2;
5557   arg2 = &temp2;
5558   temp3 = (float)jarg3;
5559   arg3 = &temp3;
5560   {
5561     try {
5562       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (Dali::DaliException e) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5574       };
5575     } catch (...) {
5576       {
5577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5578       };
5579     }
5580   }
5581
5582   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5583   return jresult;
5584 }
5585
5586
5587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5588   void * jresult ;
5589   Dali::Vector3 *result = 0 ;
5590
5591   {
5592     try {
5593       result = (Dali::Vector3 *)new Dali::Vector3();
5594     } catch (std::out_of_range& e) {
5595       {
5596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5597       };
5598     } catch (std::exception& e) {
5599       {
5600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5601       };
5602     } catch (Dali::DaliException e) {
5603       {
5604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5605       };
5606     } catch (...) {
5607       {
5608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5609       };
5610     }
5611   }
5612
5613   jresult = (void *)result;
5614   return jresult;
5615 }
5616
5617
5618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5619   void * jresult ;
5620   float arg1 ;
5621   float arg2 ;
5622   float arg3 ;
5623   Dali::Vector3 *result = 0 ;
5624
5625   arg1 = (float)jarg1;
5626   arg2 = (float)jarg2;
5627   arg3 = (float)jarg3;
5628   {
5629     try {
5630       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5631     } catch (std::out_of_range& e) {
5632       {
5633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5634       };
5635     } catch (std::exception& e) {
5636       {
5637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5638       };
5639     } catch (Dali::DaliException e) {
5640       {
5641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5642       };
5643     } catch (...) {
5644       {
5645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5646       };
5647     }
5648   }
5649
5650   jresult = (void *)result;
5651   return jresult;
5652 }
5653
5654
5655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5656   void * jresult ;
5657   float *arg1 = (float *) 0 ;
5658   Dali::Vector3 *result = 0 ;
5659
5660   arg1 = jarg1;
5661   {
5662     try {
5663       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5664     } catch (std::out_of_range& e) {
5665       {
5666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (std::exception& e) {
5669       {
5670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5671       };
5672     } catch (Dali::DaliException e) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5675       };
5676     } catch (...) {
5677       {
5678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5679       };
5680     }
5681   }
5682
5683   jresult = (void *)result;
5684
5685
5686   return jresult;
5687 }
5688
5689
5690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5691   void * jresult ;
5692   Dali::Vector2 *arg1 = 0 ;
5693   Dali::Vector3 *result = 0 ;
5694
5695   arg1 = (Dali::Vector2 *)jarg1;
5696   if (!arg1) {
5697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5698     return 0;
5699   }
5700   {
5701     try {
5702       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5703     } catch (std::out_of_range& e) {
5704       {
5705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5706       };
5707     } catch (std::exception& e) {
5708       {
5709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5710       };
5711     } catch (Dali::DaliException e) {
5712       {
5713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5714       };
5715     } catch (...) {
5716       {
5717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5718       };
5719     }
5720   }
5721
5722   jresult = (void *)result;
5723   return jresult;
5724 }
5725
5726
5727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5728   void * jresult ;
5729   Dali::Vector4 *arg1 = 0 ;
5730   Dali::Vector3 *result = 0 ;
5731
5732   arg1 = (Dali::Vector4 *)jarg1;
5733   if (!arg1) {
5734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5735     return 0;
5736   }
5737   {
5738     try {
5739       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5740     } catch (std::out_of_range& e) {
5741       {
5742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5743       };
5744     } catch (std::exception& e) {
5745       {
5746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5747       };
5748     } catch (Dali::DaliException e) {
5749       {
5750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5751       };
5752     } catch (...) {
5753       {
5754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5755       };
5756     }
5757   }
5758
5759   jresult = (void *)result;
5760   return jresult;
5761 }
5762
5763
5764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5765   void * jresult ;
5766   Dali::Vector3 *result = 0 ;
5767
5768   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5769   jresult = (void *)result;
5770   return jresult;
5771 }
5772
5773
5774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5775   void * jresult ;
5776   Dali::Vector3 *result = 0 ;
5777
5778   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5779   jresult = (void *)result;
5780   return jresult;
5781 }
5782
5783
5784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5785   void * jresult ;
5786   Dali::Vector3 *result = 0 ;
5787
5788   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5789   jresult = (void *)result;
5790   return jresult;
5791 }
5792
5793
5794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5795   void * jresult ;
5796   Dali::Vector3 *result = 0 ;
5797
5798   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5799   jresult = (void *)result;
5800   return jresult;
5801 }
5802
5803
5804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5805   void * jresult ;
5806   Dali::Vector3 *result = 0 ;
5807
5808   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5809   jresult = (void *)result;
5810   return jresult;
5811 }
5812
5813
5814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5815   void * jresult ;
5816   Dali::Vector3 *result = 0 ;
5817
5818   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5819   jresult = (void *)result;
5820   return jresult;
5821 }
5822
5823
5824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5825   void * jresult ;
5826   Dali::Vector3 *result = 0 ;
5827
5828   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5829   jresult = (void *)result;
5830   return jresult;
5831 }
5832
5833
5834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5835   void * jresult ;
5836   Dali::Vector3 *result = 0 ;
5837
5838   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5839   jresult = (void *)result;
5840   return jresult;
5841 }
5842
5843
5844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5845   void * jresult ;
5846   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5847   float *arg2 = (float *) 0 ;
5848   Dali::Vector3 *result = 0 ;
5849
5850   arg1 = (Dali::Vector3 *)jarg1;
5851   arg2 = jarg2;
5852   {
5853     try {
5854       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5855     } catch (std::out_of_range& e) {
5856       {
5857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (std::exception& e) {
5860       {
5861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5862       };
5863     } catch (Dali::DaliException e) {
5864       {
5865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5866       };
5867     } catch (...) {
5868       {
5869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5870       };
5871     }
5872   }
5873
5874   jresult = (void *)result;
5875
5876
5877   return jresult;
5878 }
5879
5880
5881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5882   void * jresult ;
5883   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5884   Dali::Vector2 *arg2 = 0 ;
5885   Dali::Vector3 *result = 0 ;
5886
5887   arg1 = (Dali::Vector3 *)jarg1;
5888   arg2 = (Dali::Vector2 *)jarg2;
5889   if (!arg2) {
5890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5891     return 0;
5892   }
5893   {
5894     try {
5895       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5896     } catch (std::out_of_range& e) {
5897       {
5898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5899       };
5900     } catch (std::exception& e) {
5901       {
5902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5903       };
5904     } catch (Dali::DaliException e) {
5905       {
5906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5907       };
5908     } catch (...) {
5909       {
5910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5911       };
5912     }
5913   }
5914
5915   jresult = (void *)result;
5916   return jresult;
5917 }
5918
5919
5920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5921   void * jresult ;
5922   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5923   Dali::Vector4 *arg2 = 0 ;
5924   Dali::Vector3 *result = 0 ;
5925
5926   arg1 = (Dali::Vector3 *)jarg1;
5927   arg2 = (Dali::Vector4 *)jarg2;
5928   if (!arg2) {
5929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5930     return 0;
5931   }
5932   {
5933     try {
5934       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5935     } catch (std::out_of_range& e) {
5936       {
5937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5938       };
5939     } catch (std::exception& e) {
5940       {
5941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5942       };
5943     } catch (Dali::DaliException e) {
5944       {
5945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5946       };
5947     } catch (...) {
5948       {
5949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5950       };
5951     }
5952   }
5953
5954   jresult = (void *)result;
5955   return jresult;
5956 }
5957
5958
5959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5960   void * jresult ;
5961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5962   Dali::Vector3 *arg2 = 0 ;
5963   Dali::Vector3 result;
5964
5965   arg1 = (Dali::Vector3 *)jarg1;
5966   arg2 = (Dali::Vector3 *)jarg2;
5967   if (!arg2) {
5968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5969     return 0;
5970   }
5971   {
5972     try {
5973       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5974     } catch (std::out_of_range& e) {
5975       {
5976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5977       };
5978     } catch (std::exception& e) {
5979       {
5980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5981       };
5982     } catch (Dali::DaliException e) {
5983       {
5984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5985       };
5986     } catch (...) {
5987       {
5988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5989       };
5990     }
5991   }
5992
5993   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5994   return jresult;
5995 }
5996
5997
5998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5999   void * jresult ;
6000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6001   Dali::Vector3 *arg2 = 0 ;
6002   Dali::Vector3 *result = 0 ;
6003
6004   arg1 = (Dali::Vector3 *)jarg1;
6005   arg2 = (Dali::Vector3 *)jarg2;
6006   if (!arg2) {
6007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6008     return 0;
6009   }
6010   {
6011     try {
6012       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6013     } catch (std::out_of_range& e) {
6014       {
6015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6016       };
6017     } catch (std::exception& e) {
6018       {
6019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6020       };
6021     } catch (Dali::DaliException e) {
6022       {
6023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6024       };
6025     } catch (...) {
6026       {
6027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6028       };
6029     }
6030   }
6031
6032   jresult = (void *)result;
6033   return jresult;
6034 }
6035
6036
6037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6038   void * jresult ;
6039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6040   Dali::Vector3 *arg2 = 0 ;
6041   Dali::Vector3 result;
6042
6043   arg1 = (Dali::Vector3 *)jarg1;
6044   arg2 = (Dali::Vector3 *)jarg2;
6045   if (!arg2) {
6046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6047     return 0;
6048   }
6049   {
6050     try {
6051       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6052     } catch (std::out_of_range& e) {
6053       {
6054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (std::exception& e) {
6057       {
6058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6059       };
6060     } catch (Dali::DaliException e) {
6061       {
6062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6063       };
6064     } catch (...) {
6065       {
6066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6067       };
6068     }
6069   }
6070
6071   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6072   return jresult;
6073 }
6074
6075
6076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6077   void * jresult ;
6078   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6079   Dali::Vector3 *arg2 = 0 ;
6080   Dali::Vector3 *result = 0 ;
6081
6082   arg1 = (Dali::Vector3 *)jarg1;
6083   arg2 = (Dali::Vector3 *)jarg2;
6084   if (!arg2) {
6085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6086     return 0;
6087   }
6088   {
6089     try {
6090       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6091     } catch (std::out_of_range& e) {
6092       {
6093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6094       };
6095     } catch (std::exception& e) {
6096       {
6097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6098       };
6099     } catch (Dali::DaliException e) {
6100       {
6101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6102       };
6103     } catch (...) {
6104       {
6105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6106       };
6107     }
6108   }
6109
6110   jresult = (void *)result;
6111   return jresult;
6112 }
6113
6114
6115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6116   void * jresult ;
6117   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6118   Dali::Vector3 *arg2 = 0 ;
6119   Dali::Vector3 result;
6120
6121   arg1 = (Dali::Vector3 *)jarg1;
6122   arg2 = (Dali::Vector3 *)jarg2;
6123   if (!arg2) {
6124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6125     return 0;
6126   }
6127   {
6128     try {
6129       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6130     } catch (std::out_of_range& e) {
6131       {
6132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6133       };
6134     } catch (std::exception& e) {
6135       {
6136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6137       };
6138     } catch (Dali::DaliException e) {
6139       {
6140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6141       };
6142     } catch (...) {
6143       {
6144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6145       };
6146     }
6147   }
6148
6149   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6150   return jresult;
6151 }
6152
6153
6154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6155   void * jresult ;
6156   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6157   float arg2 ;
6158   Dali::Vector3 result;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   arg2 = (float)jarg2;
6162   {
6163     try {
6164       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6165     } catch (std::out_of_range& e) {
6166       {
6167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6168       };
6169     } catch (std::exception& e) {
6170       {
6171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6172       };
6173     } catch (Dali::DaliException e) {
6174       {
6175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6176       };
6177     } catch (...) {
6178       {
6179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6180       };
6181     }
6182   }
6183
6184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6185   return jresult;
6186 }
6187
6188
6189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6190   void * jresult ;
6191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6192   Dali::Vector3 *arg2 = 0 ;
6193   Dali::Vector3 *result = 0 ;
6194
6195   arg1 = (Dali::Vector3 *)jarg1;
6196   arg2 = (Dali::Vector3 *)jarg2;
6197   if (!arg2) {
6198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6199     return 0;
6200   }
6201   {
6202     try {
6203       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6204     } catch (std::out_of_range& e) {
6205       {
6206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6207       };
6208     } catch (std::exception& e) {
6209       {
6210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6211       };
6212     } catch (Dali::DaliException e) {
6213       {
6214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6215       };
6216     } catch (...) {
6217       {
6218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6219       };
6220     }
6221   }
6222
6223   jresult = (void *)result;
6224   return jresult;
6225 }
6226
6227
6228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6229   void * jresult ;
6230   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6231   float arg2 ;
6232   Dali::Vector3 *result = 0 ;
6233
6234   arg1 = (Dali::Vector3 *)jarg1;
6235   arg2 = (float)jarg2;
6236   {
6237     try {
6238       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6239     } catch (std::out_of_range& e) {
6240       {
6241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6242       };
6243     } catch (std::exception& e) {
6244       {
6245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6246       };
6247     } catch (Dali::DaliException e) {
6248       {
6249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6250       };
6251     } catch (...) {
6252       {
6253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6254       };
6255     }
6256   }
6257
6258   jresult = (void *)result;
6259   return jresult;
6260 }
6261
6262
6263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6264   void * jresult ;
6265   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6266   Dali::Quaternion *arg2 = 0 ;
6267   Dali::Vector3 *result = 0 ;
6268
6269   arg1 = (Dali::Vector3 *)jarg1;
6270   arg2 = (Dali::Quaternion *)jarg2;
6271   if (!arg2) {
6272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6273     return 0;
6274   }
6275   {
6276     try {
6277       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6278     } catch (std::out_of_range& e) {
6279       {
6280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6281       };
6282     } catch (std::exception& e) {
6283       {
6284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6285       };
6286     } catch (Dali::DaliException e) {
6287       {
6288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6289       };
6290     } catch (...) {
6291       {
6292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6293       };
6294     }
6295   }
6296
6297   jresult = (void *)result;
6298   return jresult;
6299 }
6300
6301
6302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6303   void * jresult ;
6304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6305   Dali::Vector3 *arg2 = 0 ;
6306   Dali::Vector3 result;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   arg2 = (Dali::Vector3 *)jarg2;
6310   if (!arg2) {
6311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6312     return 0;
6313   }
6314   {
6315     try {
6316       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6317     } catch (std::out_of_range& e) {
6318       {
6319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6320       };
6321     } catch (std::exception& e) {
6322       {
6323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6324       };
6325     } catch (Dali::DaliException e) {
6326       {
6327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6328       };
6329     } catch (...) {
6330       {
6331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6332       };
6333     }
6334   }
6335
6336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6337   return jresult;
6338 }
6339
6340
6341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6342   void * jresult ;
6343   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6344   float arg2 ;
6345   Dali::Vector3 result;
6346
6347   arg1 = (Dali::Vector3 *)jarg1;
6348   arg2 = (float)jarg2;
6349   {
6350     try {
6351       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6352     } catch (std::out_of_range& e) {
6353       {
6354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6355       };
6356     } catch (std::exception& e) {
6357       {
6358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6359       };
6360     } catch (Dali::DaliException e) {
6361       {
6362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6363       };
6364     } catch (...) {
6365       {
6366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6367       };
6368     }
6369   }
6370
6371   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6372   return jresult;
6373 }
6374
6375
6376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6377   void * jresult ;
6378   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6379   Dali::Vector3 *arg2 = 0 ;
6380   Dali::Vector3 *result = 0 ;
6381
6382   arg1 = (Dali::Vector3 *)jarg1;
6383   arg2 = (Dali::Vector3 *)jarg2;
6384   if (!arg2) {
6385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6386     return 0;
6387   }
6388   {
6389     try {
6390       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6391     } catch (std::out_of_range& e) {
6392       {
6393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6394       };
6395     } catch (std::exception& e) {
6396       {
6397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6398       };
6399     } catch (Dali::DaliException e) {
6400       {
6401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6402       };
6403     } catch (...) {
6404       {
6405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6406       };
6407     }
6408   }
6409
6410   jresult = (void *)result;
6411   return jresult;
6412 }
6413
6414
6415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6416   void * jresult ;
6417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6418   float arg2 ;
6419   Dali::Vector3 *result = 0 ;
6420
6421   arg1 = (Dali::Vector3 *)jarg1;
6422   arg2 = (float)jarg2;
6423   {
6424     try {
6425       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6426     } catch (std::out_of_range& e) {
6427       {
6428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6429       };
6430     } catch (std::exception& e) {
6431       {
6432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6433       };
6434     } catch (Dali::DaliException e) {
6435       {
6436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6437       };
6438     } catch (...) {
6439       {
6440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6441       };
6442     }
6443   }
6444
6445   jresult = (void *)result;
6446   return jresult;
6447 }
6448
6449
6450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6451   void * jresult ;
6452   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6453   Dali::Vector3 result;
6454
6455   arg1 = (Dali::Vector3 *)jarg1;
6456   {
6457     try {
6458       result = ((Dali::Vector3 const *)arg1)->operator -();
6459     } catch (std::out_of_range& e) {
6460       {
6461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6462       };
6463     } catch (std::exception& e) {
6464       {
6465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6466       };
6467     } catch (Dali::DaliException e) {
6468       {
6469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6470       };
6471     } catch (...) {
6472       {
6473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6474       };
6475     }
6476   }
6477
6478   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6479   return jresult;
6480 }
6481
6482
6483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6484   unsigned int jresult ;
6485   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6486   Dali::Vector3 *arg2 = 0 ;
6487   bool result;
6488
6489   arg1 = (Dali::Vector3 *)jarg1;
6490   arg2 = (Dali::Vector3 *)jarg2;
6491   if (!arg2) {
6492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6493     return 0;
6494   }
6495   {
6496     try {
6497       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6498     } catch (std::out_of_range& e) {
6499       {
6500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (std::exception& e) {
6503       {
6504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6505       };
6506     } catch (Dali::DaliException e) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6509       };
6510     } catch (...) {
6511       {
6512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6513       };
6514     }
6515   }
6516
6517   jresult = result;
6518   return jresult;
6519 }
6520
6521
6522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6523   unsigned int jresult ;
6524   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6525   Dali::Vector3 *arg2 = 0 ;
6526   bool result;
6527
6528   arg1 = (Dali::Vector3 *)jarg1;
6529   arg2 = (Dali::Vector3 *)jarg2;
6530   if (!arg2) {
6531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6532     return 0;
6533   }
6534   {
6535     try {
6536       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6537     } catch (std::out_of_range& e) {
6538       {
6539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6540       };
6541     } catch (std::exception& e) {
6542       {
6543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6544       };
6545     } catch (Dali::DaliException e) {
6546       {
6547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6548       };
6549     } catch (...) {
6550       {
6551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6552       };
6553     }
6554   }
6555
6556   jresult = result;
6557   return jresult;
6558 }
6559
6560
6561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6562   float jresult ;
6563   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6564   unsigned int arg2 ;
6565   float *result = 0 ;
6566
6567   arg1 = (Dali::Vector3 *)jarg1;
6568   arg2 = (unsigned int)jarg2;
6569   {
6570     try {
6571       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6572     } catch (std::out_of_range& e) {
6573       {
6574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6575       };
6576     } catch (std::exception& e) {
6577       {
6578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6579       };
6580     } catch (Dali::DaliException e) {
6581       {
6582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6583       };
6584     } catch (...) {
6585       {
6586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6587       };
6588     }
6589   }
6590
6591   jresult = *result;
6592   return jresult;
6593 }
6594
6595
6596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6597   float jresult ;
6598   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6599   Dali::Vector3 *arg2 = 0 ;
6600   float result;
6601
6602   arg1 = (Dali::Vector3 *)jarg1;
6603   arg2 = (Dali::Vector3 *)jarg2;
6604   if (!arg2) {
6605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6606     return 0;
6607   }
6608   {
6609     try {
6610       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6611     } catch (std::out_of_range& e) {
6612       {
6613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (std::exception& e) {
6616       {
6617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6618       };
6619     } catch (Dali::DaliException e) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6622       };
6623     } catch (...) {
6624       {
6625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6626       };
6627     }
6628   }
6629
6630   jresult = result;
6631   return jresult;
6632 }
6633
6634
6635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6636   void * jresult ;
6637   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6638   Dali::Vector3 *arg2 = 0 ;
6639   Dali::Vector3 result;
6640
6641   arg1 = (Dali::Vector3 *)jarg1;
6642   arg2 = (Dali::Vector3 *)jarg2;
6643   if (!arg2) {
6644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6645     return 0;
6646   }
6647   {
6648     try {
6649       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6650     } catch (std::out_of_range& e) {
6651       {
6652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (std::exception& e) {
6655       {
6656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6657       };
6658     } catch (Dali::DaliException e) {
6659       {
6660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6661       };
6662     } catch (...) {
6663       {
6664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6665       };
6666     }
6667   }
6668
6669   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6670   return jresult;
6671 }
6672
6673
6674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6675   float jresult ;
6676   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6677   float result;
6678
6679   arg1 = (Dali::Vector3 *)jarg1;
6680   {
6681     try {
6682       result = (float)((Dali::Vector3 const *)arg1)->Length();
6683     } catch (std::out_of_range& e) {
6684       {
6685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6686       };
6687     } catch (std::exception& e) {
6688       {
6689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6690       };
6691     } catch (Dali::DaliException e) {
6692       {
6693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6694       };
6695     } catch (...) {
6696       {
6697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6698       };
6699     }
6700   }
6701
6702   jresult = result;
6703   return jresult;
6704 }
6705
6706
6707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6708   float jresult ;
6709   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6710   float result;
6711
6712   arg1 = (Dali::Vector3 *)jarg1;
6713   {
6714     try {
6715       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6716     } catch (std::out_of_range& e) {
6717       {
6718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (std::exception& e) {
6721       {
6722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6723       };
6724     } catch (Dali::DaliException e) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6727       };
6728     } catch (...) {
6729       {
6730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6731       };
6732     }
6733   }
6734
6735   jresult = result;
6736   return jresult;
6737 }
6738
6739
6740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6741   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6742
6743   arg1 = (Dali::Vector3 *)jarg1;
6744   {
6745     try {
6746       (arg1)->Normalize();
6747     } catch (std::out_of_range& e) {
6748       {
6749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6750       };
6751     } catch (std::exception& e) {
6752       {
6753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6754       };
6755     } catch (Dali::DaliException e) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6758       };
6759     } catch (...) {
6760       {
6761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6762       };
6763     }
6764   }
6765
6766 }
6767
6768
6769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6770   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6771   Dali::Vector3 *arg2 = 0 ;
6772   Dali::Vector3 *arg3 = 0 ;
6773
6774   arg1 = (Dali::Vector3 *)jarg1;
6775   arg2 = (Dali::Vector3 *)jarg2;
6776   if (!arg2) {
6777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6778     return ;
6779   }
6780   arg3 = (Dali::Vector3 *)jarg3;
6781   if (!arg3) {
6782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6783     return ;
6784   }
6785   {
6786     try {
6787       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6788     } catch (std::out_of_range& e) {
6789       {
6790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6791       };
6792     } catch (std::exception& e) {
6793       {
6794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6795       };
6796     } catch (Dali::DaliException e) {
6797       {
6798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6803       };
6804     }
6805   }
6806
6807 }
6808
6809
6810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6811   void * jresult ;
6812   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6813   float *result = 0 ;
6814
6815   arg1 = (Dali::Vector3 *)jarg1;
6816   {
6817     try {
6818       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6819     } catch (std::out_of_range& e) {
6820       {
6821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6822       };
6823     } catch (std::exception& e) {
6824       {
6825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6826       };
6827     } catch (Dali::DaliException e) {
6828       {
6829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6830       };
6831     } catch (...) {
6832       {
6833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6834       };
6835     }
6836   }
6837
6838   jresult = (void *)result;
6839   return jresult;
6840 }
6841
6842
6843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6844   void * jresult ;
6845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6846   Dali::Vector2 *result = 0 ;
6847
6848   arg1 = (Dali::Vector3 *)jarg1;
6849   {
6850     try {
6851       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6852     } catch (std::out_of_range& e) {
6853       {
6854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6855       };
6856     } catch (std::exception& e) {
6857       {
6858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6859       };
6860     } catch (Dali::DaliException e) {
6861       {
6862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6863       };
6864     } catch (...) {
6865       {
6866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6867       };
6868     }
6869   }
6870
6871   jresult = (void *)result;
6872   return jresult;
6873 }
6874
6875
6876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6877   void * jresult ;
6878   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6879   Dali::Vector2 *result = 0 ;
6880
6881   arg1 = (Dali::Vector3 *)jarg1;
6882   {
6883     try {
6884       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6885     } catch (std::out_of_range& e) {
6886       {
6887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (std::exception& e) {
6890       {
6891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6892       };
6893     } catch (Dali::DaliException e) {
6894       {
6895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6896       };
6897     } catch (...) {
6898       {
6899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6900       };
6901     }
6902   }
6903
6904   jresult = (void *)result;
6905   return jresult;
6906 }
6907
6908
6909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6910   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6911   float arg2 ;
6912
6913   arg1 = (Dali::Vector3 *)jarg1;
6914   arg2 = (float)jarg2;
6915   if (arg1) (arg1)->x = arg2;
6916 }
6917
6918
6919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6920   float jresult ;
6921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6922   float result;
6923
6924   arg1 = (Dali::Vector3 *)jarg1;
6925   result = (float) ((arg1)->x);
6926   jresult = result;
6927   return jresult;
6928 }
6929
6930
6931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6932   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6933   float arg2 ;
6934
6935   arg1 = (Dali::Vector3 *)jarg1;
6936   arg2 = (float)jarg2;
6937   if (arg1) (arg1)->width = arg2;
6938 }
6939
6940
6941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6942   float jresult ;
6943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6944   float result;
6945
6946   arg1 = (Dali::Vector3 *)jarg1;
6947   result = (float) ((arg1)->width);
6948   jresult = result;
6949   return jresult;
6950 }
6951
6952
6953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6955   float arg2 ;
6956
6957   arg1 = (Dali::Vector3 *)jarg1;
6958   arg2 = (float)jarg2;
6959   if (arg1) (arg1)->r = arg2;
6960 }
6961
6962
6963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6964   float jresult ;
6965   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6966   float result;
6967
6968   arg1 = (Dali::Vector3 *)jarg1;
6969   result = (float) ((arg1)->r);
6970   jresult = result;
6971   return jresult;
6972 }
6973
6974
6975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6977   float arg2 ;
6978
6979   arg1 = (Dali::Vector3 *)jarg1;
6980   arg2 = (float)jarg2;
6981   if (arg1) (arg1)->y = arg2;
6982 }
6983
6984
6985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6986   float jresult ;
6987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6988   float result;
6989
6990   arg1 = (Dali::Vector3 *)jarg1;
6991   result = (float) ((arg1)->y);
6992   jresult = result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6998   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6999   float arg2 ;
7000
7001   arg1 = (Dali::Vector3 *)jarg1;
7002   arg2 = (float)jarg2;
7003   if (arg1) (arg1)->height = arg2;
7004 }
7005
7006
7007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7008   float jresult ;
7009   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7010   float result;
7011
7012   arg1 = (Dali::Vector3 *)jarg1;
7013   result = (float) ((arg1)->height);
7014   jresult = result;
7015   return jresult;
7016 }
7017
7018
7019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7021   float arg2 ;
7022
7023   arg1 = (Dali::Vector3 *)jarg1;
7024   arg2 = (float)jarg2;
7025   if (arg1) (arg1)->g = arg2;
7026 }
7027
7028
7029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7030   float jresult ;
7031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7032   float result;
7033
7034   arg1 = (Dali::Vector3 *)jarg1;
7035   result = (float) ((arg1)->g);
7036   jresult = result;
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7043   float arg2 ;
7044
7045   arg1 = (Dali::Vector3 *)jarg1;
7046   arg2 = (float)jarg2;
7047   if (arg1) (arg1)->z = arg2;
7048 }
7049
7050
7051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7052   float jresult ;
7053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7054   float result;
7055
7056   arg1 = (Dali::Vector3 *)jarg1;
7057   result = (float) ((arg1)->z);
7058   jresult = result;
7059   return jresult;
7060 }
7061
7062
7063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7065   float arg2 ;
7066
7067   arg1 = (Dali::Vector3 *)jarg1;
7068   arg2 = (float)jarg2;
7069   if (arg1) (arg1)->depth = arg2;
7070 }
7071
7072
7073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7074   float jresult ;
7075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7076   float result;
7077
7078   arg1 = (Dali::Vector3 *)jarg1;
7079   result = (float) ((arg1)->depth);
7080   jresult = result;
7081   return jresult;
7082 }
7083
7084
7085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7087   float arg2 ;
7088
7089   arg1 = (Dali::Vector3 *)jarg1;
7090   arg2 = (float)jarg2;
7091   if (arg1) (arg1)->b = arg2;
7092 }
7093
7094
7095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7096   float jresult ;
7097   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7098   float result;
7099
7100   arg1 = (Dali::Vector3 *)jarg1;
7101   result = (float) ((arg1)->b);
7102   jresult = result;
7103   return jresult;
7104 }
7105
7106
7107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7108   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7109
7110   arg1 = (Dali::Vector3 *)jarg1;
7111   {
7112     try {
7113       delete arg1;
7114     } catch (std::out_of_range& e) {
7115       {
7116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7117       };
7118     } catch (std::exception& e) {
7119       {
7120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7121       };
7122     } catch (Dali::DaliException e) {
7123       {
7124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7125       };
7126     } catch (...) {
7127       {
7128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7129       };
7130     }
7131   }
7132
7133 }
7134
7135
7136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7137   void * jresult ;
7138   Dali::Vector3 *arg1 = 0 ;
7139   Dali::Vector3 *arg2 = 0 ;
7140   Dali::Vector3 result;
7141
7142   arg1 = (Dali::Vector3 *)jarg1;
7143   if (!arg1) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7145     return 0;
7146   }
7147   arg2 = (Dali::Vector3 *)jarg2;
7148   if (!arg2) {
7149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7150     return 0;
7151   }
7152   {
7153     try {
7154       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7155     } catch (std::out_of_range& e) {
7156       {
7157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (std::exception& e) {
7160       {
7161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7162       };
7163     } catch (Dali::DaliException e) {
7164       {
7165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7166       };
7167     } catch (...) {
7168       {
7169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7170       };
7171     }
7172   }
7173
7174   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7175   return jresult;
7176 }
7177
7178
7179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7180   void * jresult ;
7181   Dali::Vector3 *arg1 = 0 ;
7182   Dali::Vector3 *arg2 = 0 ;
7183   Dali::Vector3 result;
7184
7185   arg1 = (Dali::Vector3 *)jarg1;
7186   if (!arg1) {
7187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7188     return 0;
7189   }
7190   arg2 = (Dali::Vector3 *)jarg2;
7191   if (!arg2) {
7192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7193     return 0;
7194   }
7195   {
7196     try {
7197       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7198     } catch (std::out_of_range& e) {
7199       {
7200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (std::exception& e) {
7203       {
7204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7205       };
7206     } catch (Dali::DaliException e) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7209       };
7210     } catch (...) {
7211       {
7212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7213       };
7214     }
7215   }
7216
7217   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7218   return jresult;
7219 }
7220
7221
7222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7223   void * jresult ;
7224   Dali::Vector3 *arg1 = 0 ;
7225   float *arg2 = 0 ;
7226   float *arg3 = 0 ;
7227   float temp2 ;
7228   float temp3 ;
7229   Dali::Vector3 result;
7230
7231   arg1 = (Dali::Vector3 *)jarg1;
7232   if (!arg1) {
7233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7234     return 0;
7235   }
7236   temp2 = (float)jarg2;
7237   arg2 = &temp2;
7238   temp3 = (float)jarg3;
7239   arg3 = &temp3;
7240   {
7241     try {
7242       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7243     } catch (std::out_of_range& e) {
7244       {
7245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7246       };
7247     } catch (std::exception& e) {
7248       {
7249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7250       };
7251     } catch (Dali::DaliException e) {
7252       {
7253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7254       };
7255     } catch (...) {
7256       {
7257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7258       };
7259     }
7260   }
7261
7262   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7263   return jresult;
7264 }
7265
7266
7267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7268   void * jresult ;
7269   Dali::Vector4 *result = 0 ;
7270
7271   {
7272     try {
7273       result = (Dali::Vector4 *)new Dali::Vector4();
7274     } catch (std::out_of_range& e) {
7275       {
7276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7277       };
7278     } catch (std::exception& e) {
7279       {
7280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7281       };
7282     } catch (Dali::DaliException e) {
7283       {
7284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7285       };
7286     } catch (...) {
7287       {
7288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7289       };
7290     }
7291   }
7292
7293   jresult = (void *)result;
7294   return jresult;
7295 }
7296
7297
7298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7299   void * jresult ;
7300   float arg1 ;
7301   float arg2 ;
7302   float arg3 ;
7303   float arg4 ;
7304   Dali::Vector4 *result = 0 ;
7305
7306   arg1 = (float)jarg1;
7307   arg2 = (float)jarg2;
7308   arg3 = (float)jarg3;
7309   arg4 = (float)jarg4;
7310   {
7311     try {
7312       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7313     } catch (std::out_of_range& e) {
7314       {
7315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7316       };
7317     } catch (std::exception& e) {
7318       {
7319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7320       };
7321     } catch (Dali::DaliException e) {
7322       {
7323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7324       };
7325     } catch (...) {
7326       {
7327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7328       };
7329     }
7330   }
7331
7332   jresult = (void *)result;
7333   return jresult;
7334 }
7335
7336
7337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7338   void * jresult ;
7339   float *arg1 = (float *) 0 ;
7340   Dali::Vector4 *result = 0 ;
7341
7342   arg1 = jarg1;
7343   {
7344     try {
7345       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7346     } catch (std::out_of_range& e) {
7347       {
7348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7349       };
7350     } catch (std::exception& e) {
7351       {
7352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7353       };
7354     } catch (Dali::DaliException e) {
7355       {
7356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7357       };
7358     } catch (...) {
7359       {
7360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7361       };
7362     }
7363   }
7364
7365   jresult = (void *)result;
7366
7367
7368   return jresult;
7369 }
7370
7371
7372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7373   void * jresult ;
7374   Dali::Vector2 *arg1 = 0 ;
7375   Dali::Vector4 *result = 0 ;
7376
7377   arg1 = (Dali::Vector2 *)jarg1;
7378   if (!arg1) {
7379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7380     return 0;
7381   }
7382   {
7383     try {
7384       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7385     } catch (std::out_of_range& e) {
7386       {
7387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7388       };
7389     } catch (std::exception& e) {
7390       {
7391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7392       };
7393     } catch (Dali::DaliException e) {
7394       {
7395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7396       };
7397     } catch (...) {
7398       {
7399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7400       };
7401     }
7402   }
7403
7404   jresult = (void *)result;
7405   return jresult;
7406 }
7407
7408
7409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7410   void * jresult ;
7411   Dali::Vector3 *arg1 = 0 ;
7412   Dali::Vector4 *result = 0 ;
7413
7414   arg1 = (Dali::Vector3 *)jarg1;
7415   if (!arg1) {
7416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7417     return 0;
7418   }
7419   {
7420     try {
7421       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7422     } catch (std::out_of_range& e) {
7423       {
7424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7425       };
7426     } catch (std::exception& e) {
7427       {
7428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7429       };
7430     } catch (Dali::DaliException e) {
7431       {
7432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7433       };
7434     } catch (...) {
7435       {
7436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7437       };
7438     }
7439   }
7440
7441   jresult = (void *)result;
7442   return jresult;
7443 }
7444
7445
7446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7447   void * jresult ;
7448   Dali::Vector4 *result = 0 ;
7449
7450   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7451   jresult = (void *)result;
7452   return jresult;
7453 }
7454
7455
7456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7457   void * jresult ;
7458   Dali::Vector4 *result = 0 ;
7459
7460   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7461   jresult = (void *)result;
7462   return jresult;
7463 }
7464
7465
7466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7467   void * jresult ;
7468   Dali::Vector4 *result = 0 ;
7469
7470   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7471   jresult = (void *)result;
7472   return jresult;
7473 }
7474
7475
7476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7477   void * jresult ;
7478   Dali::Vector4 *result = 0 ;
7479
7480   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7481   jresult = (void *)result;
7482   return jresult;
7483 }
7484
7485
7486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7487   void * jresult ;
7488   Dali::Vector4 *result = 0 ;
7489
7490   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7491   jresult = (void *)result;
7492   return jresult;
7493 }
7494
7495
7496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7497   void * jresult ;
7498   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7499   float *arg2 = (float *) 0 ;
7500   Dali::Vector4 *result = 0 ;
7501
7502   arg1 = (Dali::Vector4 *)jarg1;
7503   arg2 = jarg2;
7504   {
7505     try {
7506       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7507     } catch (std::out_of_range& e) {
7508       {
7509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7510       };
7511     } catch (std::exception& e) {
7512       {
7513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7514       };
7515     } catch (Dali::DaliException e) {
7516       {
7517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7518       };
7519     } catch (...) {
7520       {
7521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7522       };
7523     }
7524   }
7525
7526   jresult = (void *)result;
7527
7528
7529   return jresult;
7530 }
7531
7532
7533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7534   void * jresult ;
7535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7536   Dali::Vector2 *arg2 = 0 ;
7537   Dali::Vector4 *result = 0 ;
7538
7539   arg1 = (Dali::Vector4 *)jarg1;
7540   arg2 = (Dali::Vector2 *)jarg2;
7541   if (!arg2) {
7542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7543     return 0;
7544   }
7545   {
7546     try {
7547       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7548     } catch (std::out_of_range& e) {
7549       {
7550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (std::exception& e) {
7553       {
7554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7555       };
7556     } catch (Dali::DaliException e) {
7557       {
7558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7559       };
7560     } catch (...) {
7561       {
7562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7563       };
7564     }
7565   }
7566
7567   jresult = (void *)result;
7568   return jresult;
7569 }
7570
7571
7572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7573   void * jresult ;
7574   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7575   Dali::Vector3 *arg2 = 0 ;
7576   Dali::Vector4 *result = 0 ;
7577
7578   arg1 = (Dali::Vector4 *)jarg1;
7579   arg2 = (Dali::Vector3 *)jarg2;
7580   if (!arg2) {
7581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7582     return 0;
7583   }
7584   {
7585     try {
7586       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7587     } catch (std::out_of_range& e) {
7588       {
7589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7590       };
7591     } catch (std::exception& e) {
7592       {
7593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7594       };
7595     } catch (Dali::DaliException e) {
7596       {
7597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7598       };
7599     } catch (...) {
7600       {
7601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7602       };
7603     }
7604   }
7605
7606   jresult = (void *)result;
7607   return jresult;
7608 }
7609
7610
7611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7612   void * jresult ;
7613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7614   Dali::Vector4 *arg2 = 0 ;
7615   Dali::Vector4 result;
7616
7617   arg1 = (Dali::Vector4 *)jarg1;
7618   arg2 = (Dali::Vector4 *)jarg2;
7619   if (!arg2) {
7620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7621     return 0;
7622   }
7623   {
7624     try {
7625       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7626     } catch (std::out_of_range& e) {
7627       {
7628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7629       };
7630     } catch (std::exception& e) {
7631       {
7632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7633       };
7634     } catch (Dali::DaliException e) {
7635       {
7636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7637       };
7638     } catch (...) {
7639       {
7640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7641       };
7642     }
7643   }
7644
7645   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7646   return jresult;
7647 }
7648
7649
7650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7651   void * jresult ;
7652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7653   Dali::Vector4 *arg2 = 0 ;
7654   Dali::Vector4 *result = 0 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   arg2 = (Dali::Vector4 *)jarg2;
7658   if (!arg2) {
7659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7660     return 0;
7661   }
7662   {
7663     try {
7664       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7665     } catch (std::out_of_range& e) {
7666       {
7667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7668       };
7669     } catch (std::exception& e) {
7670       {
7671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7672       };
7673     } catch (Dali::DaliException e) {
7674       {
7675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7676       };
7677     } catch (...) {
7678       {
7679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7680       };
7681     }
7682   }
7683
7684   jresult = (void *)result;
7685   return jresult;
7686 }
7687
7688
7689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7690   void * jresult ;
7691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7692   Dali::Vector4 *arg2 = 0 ;
7693   Dali::Vector4 result;
7694
7695   arg1 = (Dali::Vector4 *)jarg1;
7696   arg2 = (Dali::Vector4 *)jarg2;
7697   if (!arg2) {
7698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7699     return 0;
7700   }
7701   {
7702     try {
7703       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7704     } catch (std::out_of_range& e) {
7705       {
7706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7707       };
7708     } catch (std::exception& e) {
7709       {
7710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7711       };
7712     } catch (Dali::DaliException e) {
7713       {
7714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7715       };
7716     } catch (...) {
7717       {
7718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7719       };
7720     }
7721   }
7722
7723   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7724   return jresult;
7725 }
7726
7727
7728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7729   void * jresult ;
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   Dali::Vector4 *arg2 = 0 ;
7732   Dali::Vector4 *result = 0 ;
7733
7734   arg1 = (Dali::Vector4 *)jarg1;
7735   arg2 = (Dali::Vector4 *)jarg2;
7736   if (!arg2) {
7737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7738     return 0;
7739   }
7740   {
7741     try {
7742       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7743     } catch (std::out_of_range& e) {
7744       {
7745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7746       };
7747     } catch (std::exception& e) {
7748       {
7749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7750       };
7751     } catch (Dali::DaliException e) {
7752       {
7753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7754       };
7755     } catch (...) {
7756       {
7757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7758       };
7759     }
7760   }
7761
7762   jresult = (void *)result;
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7768   void * jresult ;
7769   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7770   Dali::Vector4 *arg2 = 0 ;
7771   Dali::Vector4 result;
7772
7773   arg1 = (Dali::Vector4 *)jarg1;
7774   arg2 = (Dali::Vector4 *)jarg2;
7775   if (!arg2) {
7776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7777     return 0;
7778   }
7779   {
7780     try {
7781       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7782     } catch (std::out_of_range& e) {
7783       {
7784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7785       };
7786     } catch (std::exception& e) {
7787       {
7788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7789       };
7790     } catch (Dali::DaliException e) {
7791       {
7792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7793       };
7794     } catch (...) {
7795       {
7796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7797       };
7798     }
7799   }
7800
7801   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7802   return jresult;
7803 }
7804
7805
7806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7807   void * jresult ;
7808   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7809   float arg2 ;
7810   Dali::Vector4 result;
7811
7812   arg1 = (Dali::Vector4 *)jarg1;
7813   arg2 = (float)jarg2;
7814   {
7815     try {
7816       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7817     } catch (std::out_of_range& e) {
7818       {
7819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7820       };
7821     } catch (std::exception& e) {
7822       {
7823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7824       };
7825     } catch (Dali::DaliException e) {
7826       {
7827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7828       };
7829     } catch (...) {
7830       {
7831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7832       };
7833     }
7834   }
7835
7836   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7837   return jresult;
7838 }
7839
7840
7841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7842   void * jresult ;
7843   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7844   Dali::Vector4 *arg2 = 0 ;
7845   Dali::Vector4 *result = 0 ;
7846
7847   arg1 = (Dali::Vector4 *)jarg1;
7848   arg2 = (Dali::Vector4 *)jarg2;
7849   if (!arg2) {
7850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7851     return 0;
7852   }
7853   {
7854     try {
7855       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7856     } catch (std::out_of_range& e) {
7857       {
7858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7859       };
7860     } catch (std::exception& e) {
7861       {
7862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7863       };
7864     } catch (Dali::DaliException e) {
7865       {
7866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7867       };
7868     } catch (...) {
7869       {
7870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7871       };
7872     }
7873   }
7874
7875   jresult = (void *)result;
7876   return jresult;
7877 }
7878
7879
7880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7881   void * jresult ;
7882   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7883   float arg2 ;
7884   Dali::Vector4 *result = 0 ;
7885
7886   arg1 = (Dali::Vector4 *)jarg1;
7887   arg2 = (float)jarg2;
7888   {
7889     try {
7890       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7891     } catch (std::out_of_range& e) {
7892       {
7893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7894       };
7895     } catch (std::exception& e) {
7896       {
7897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7898       };
7899     } catch (Dali::DaliException e) {
7900       {
7901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7902       };
7903     } catch (...) {
7904       {
7905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7906       };
7907     }
7908   }
7909
7910   jresult = (void *)result;
7911   return jresult;
7912 }
7913
7914
7915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7916   void * jresult ;
7917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7918   Dali::Vector4 *arg2 = 0 ;
7919   Dali::Vector4 result;
7920
7921   arg1 = (Dali::Vector4 *)jarg1;
7922   arg2 = (Dali::Vector4 *)jarg2;
7923   if (!arg2) {
7924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7925     return 0;
7926   }
7927   {
7928     try {
7929       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7930     } catch (std::out_of_range& e) {
7931       {
7932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7933       };
7934     } catch (std::exception& e) {
7935       {
7936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7937       };
7938     } catch (Dali::DaliException e) {
7939       {
7940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7941       };
7942     } catch (...) {
7943       {
7944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7945       };
7946     }
7947   }
7948
7949   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7950   return jresult;
7951 }
7952
7953
7954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7955   void * jresult ;
7956   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7957   float arg2 ;
7958   Dali::Vector4 result;
7959
7960   arg1 = (Dali::Vector4 *)jarg1;
7961   arg2 = (float)jarg2;
7962   {
7963     try {
7964       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7965     } catch (std::out_of_range& e) {
7966       {
7967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7968       };
7969     } catch (std::exception& e) {
7970       {
7971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7972       };
7973     } catch (Dali::DaliException e) {
7974       {
7975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7976       };
7977     } catch (...) {
7978       {
7979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7980       };
7981     }
7982   }
7983
7984   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7985   return jresult;
7986 }
7987
7988
7989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7990   void * jresult ;
7991   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7992   Dali::Vector4 *arg2 = 0 ;
7993   Dali::Vector4 *result = 0 ;
7994
7995   arg1 = (Dali::Vector4 *)jarg1;
7996   arg2 = (Dali::Vector4 *)jarg2;
7997   if (!arg2) {
7998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7999     return 0;
8000   }
8001   {
8002     try {
8003       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8004     } catch (std::out_of_range& e) {
8005       {
8006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (std::exception& e) {
8009       {
8010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (Dali::DaliException e) {
8013       {
8014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8015       };
8016     } catch (...) {
8017       {
8018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8019       };
8020     }
8021   }
8022
8023   jresult = (void *)result;
8024   return jresult;
8025 }
8026
8027
8028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8029   void * jresult ;
8030   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8031   float arg2 ;
8032   Dali::Vector4 *result = 0 ;
8033
8034   arg1 = (Dali::Vector4 *)jarg1;
8035   arg2 = (float)jarg2;
8036   {
8037     try {
8038       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8039     } catch (std::out_of_range& e) {
8040       {
8041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8042       };
8043     } catch (std::exception& e) {
8044       {
8045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8046       };
8047     } catch (Dali::DaliException e) {
8048       {
8049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8050       };
8051     } catch (...) {
8052       {
8053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8054       };
8055     }
8056   }
8057
8058   jresult = (void *)result;
8059   return jresult;
8060 }
8061
8062
8063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8064   void * jresult ;
8065   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8066   Dali::Vector4 result;
8067
8068   arg1 = (Dali::Vector4 *)jarg1;
8069   {
8070     try {
8071       result = ((Dali::Vector4 const *)arg1)->operator -();
8072     } catch (std::out_of_range& e) {
8073       {
8074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8075       };
8076     } catch (std::exception& e) {
8077       {
8078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8079       };
8080     } catch (Dali::DaliException e) {
8081       {
8082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8083       };
8084     } catch (...) {
8085       {
8086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8087       };
8088     }
8089   }
8090
8091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8092   return jresult;
8093 }
8094
8095
8096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8097   unsigned int jresult ;
8098   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8099   Dali::Vector4 *arg2 = 0 ;
8100   bool result;
8101
8102   arg1 = (Dali::Vector4 *)jarg1;
8103   arg2 = (Dali::Vector4 *)jarg2;
8104   if (!arg2) {
8105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8106     return 0;
8107   }
8108   {
8109     try {
8110       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8111     } catch (std::out_of_range& e) {
8112       {
8113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8114       };
8115     } catch (std::exception& e) {
8116       {
8117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8118       };
8119     } catch (Dali::DaliException e) {
8120       {
8121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8122       };
8123     } catch (...) {
8124       {
8125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8126       };
8127     }
8128   }
8129
8130   jresult = result;
8131   return jresult;
8132 }
8133
8134
8135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8136   unsigned int jresult ;
8137   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8138   Dali::Vector4 *arg2 = 0 ;
8139   bool result;
8140
8141   arg1 = (Dali::Vector4 *)jarg1;
8142   arg2 = (Dali::Vector4 *)jarg2;
8143   if (!arg2) {
8144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8145     return 0;
8146   }
8147   {
8148     try {
8149       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8150     } catch (std::out_of_range& e) {
8151       {
8152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8153       };
8154     } catch (std::exception& e) {
8155       {
8156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8157       };
8158     } catch (Dali::DaliException e) {
8159       {
8160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8161       };
8162     } catch (...) {
8163       {
8164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8165       };
8166     }
8167   }
8168
8169   jresult = result;
8170   return jresult;
8171 }
8172
8173
8174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8175   float jresult ;
8176   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8177   unsigned int arg2 ;
8178   float *result = 0 ;
8179
8180   arg1 = (Dali::Vector4 *)jarg1;
8181   arg2 = (unsigned int)jarg2;
8182   {
8183     try {
8184       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8185     } catch (std::out_of_range& e) {
8186       {
8187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8188       };
8189     } catch (std::exception& e) {
8190       {
8191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8192       };
8193     } catch (Dali::DaliException e) {
8194       {
8195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8196       };
8197     } catch (...) {
8198       {
8199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8200       };
8201     }
8202   }
8203
8204   jresult = *result;
8205   return jresult;
8206 }
8207
8208
8209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8210   float jresult ;
8211   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8212   Dali::Vector3 *arg2 = 0 ;
8213   float result;
8214
8215   arg1 = (Dali::Vector4 *)jarg1;
8216   arg2 = (Dali::Vector3 *)jarg2;
8217   if (!arg2) {
8218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8219     return 0;
8220   }
8221   {
8222     try {
8223       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8224     } catch (std::out_of_range& e) {
8225       {
8226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8227       };
8228     } catch (std::exception& e) {
8229       {
8230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8231       };
8232     } catch (Dali::DaliException e) {
8233       {
8234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8235       };
8236     } catch (...) {
8237       {
8238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8239       };
8240     }
8241   }
8242
8243   jresult = result;
8244   return jresult;
8245 }
8246
8247
8248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8249   float jresult ;
8250   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8251   Dali::Vector4 *arg2 = 0 ;
8252   float result;
8253
8254   arg1 = (Dali::Vector4 *)jarg1;
8255   arg2 = (Dali::Vector4 *)jarg2;
8256   if (!arg2) {
8257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8258     return 0;
8259   }
8260   {
8261     try {
8262       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8263     } catch (std::out_of_range& e) {
8264       {
8265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8266       };
8267     } catch (std::exception& e) {
8268       {
8269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8270       };
8271     } catch (Dali::DaliException e) {
8272       {
8273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8274       };
8275     } catch (...) {
8276       {
8277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8278       };
8279     }
8280   }
8281
8282   jresult = result;
8283   return jresult;
8284 }
8285
8286
8287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8288   float jresult ;
8289   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8290   Dali::Vector4 *arg2 = 0 ;
8291   float result;
8292
8293   arg1 = (Dali::Vector4 *)jarg1;
8294   arg2 = (Dali::Vector4 *)jarg2;
8295   if (!arg2) {
8296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8297     return 0;
8298   }
8299   {
8300     try {
8301       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8302     } catch (std::out_of_range& e) {
8303       {
8304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8305       };
8306     } catch (std::exception& e) {
8307       {
8308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8309       };
8310     } catch (Dali::DaliException e) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8313       };
8314     } catch (...) {
8315       {
8316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8317       };
8318     }
8319   }
8320
8321   jresult = result;
8322   return jresult;
8323 }
8324
8325
8326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8327   void * jresult ;
8328   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8329   Dali::Vector4 *arg2 = 0 ;
8330   Dali::Vector4 result;
8331
8332   arg1 = (Dali::Vector4 *)jarg1;
8333   arg2 = (Dali::Vector4 *)jarg2;
8334   if (!arg2) {
8335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8336     return 0;
8337   }
8338   {
8339     try {
8340       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8341     } catch (std::out_of_range& e) {
8342       {
8343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8344       };
8345     } catch (std::exception& e) {
8346       {
8347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8348       };
8349     } catch (Dali::DaliException e) {
8350       {
8351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8352       };
8353     } catch (...) {
8354       {
8355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8356       };
8357     }
8358   }
8359
8360   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8361   return jresult;
8362 }
8363
8364
8365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8366   float jresult ;
8367   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8368   float result;
8369
8370   arg1 = (Dali::Vector4 *)jarg1;
8371   {
8372     try {
8373       result = (float)((Dali::Vector4 const *)arg1)->Length();
8374     } catch (std::out_of_range& e) {
8375       {
8376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (std::exception& e) {
8379       {
8380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8381       };
8382     } catch (Dali::DaliException e) {
8383       {
8384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8385       };
8386     } catch (...) {
8387       {
8388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8389       };
8390     }
8391   }
8392
8393   jresult = result;
8394   return jresult;
8395 }
8396
8397
8398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8399   float jresult ;
8400   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8401   float result;
8402
8403   arg1 = (Dali::Vector4 *)jarg1;
8404   {
8405     try {
8406       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8407     } catch (std::out_of_range& e) {
8408       {
8409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (std::exception& e) {
8412       {
8413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8414       };
8415     } catch (Dali::DaliException e) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8418       };
8419     } catch (...) {
8420       {
8421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8422       };
8423     }
8424   }
8425
8426   jresult = result;
8427   return jresult;
8428 }
8429
8430
8431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8432   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8433
8434   arg1 = (Dali::Vector4 *)jarg1;
8435   {
8436     try {
8437       (arg1)->Normalize();
8438     } catch (std::out_of_range& e) {
8439       {
8440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8441       };
8442     } catch (std::exception& e) {
8443       {
8444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8445       };
8446     } catch (Dali::DaliException e) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8449       };
8450     } catch (...) {
8451       {
8452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8453       };
8454     }
8455   }
8456
8457 }
8458
8459
8460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8461   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8462   Dali::Vector4 *arg2 = 0 ;
8463   Dali::Vector4 *arg3 = 0 ;
8464
8465   arg1 = (Dali::Vector4 *)jarg1;
8466   arg2 = (Dali::Vector4 *)jarg2;
8467   if (!arg2) {
8468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8469     return ;
8470   }
8471   arg3 = (Dali::Vector4 *)jarg3;
8472   if (!arg3) {
8473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8474     return ;
8475   }
8476   {
8477     try {
8478       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8479     } catch (std::out_of_range& e) {
8480       {
8481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8482       };
8483     } catch (std::exception& e) {
8484       {
8485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8486       };
8487     } catch (Dali::DaliException e) {
8488       {
8489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8490       };
8491     } catch (...) {
8492       {
8493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8494       };
8495     }
8496   }
8497
8498 }
8499
8500
8501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8502   void * jresult ;
8503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8504   float *result = 0 ;
8505
8506   arg1 = (Dali::Vector4 *)jarg1;
8507   {
8508     try {
8509       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8510     } catch (std::out_of_range& e) {
8511       {
8512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8513       };
8514     } catch (std::exception& e) {
8515       {
8516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8517       };
8518     } catch (Dali::DaliException e) {
8519       {
8520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8521       };
8522     } catch (...) {
8523       {
8524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8525       };
8526     }
8527   }
8528
8529   jresult = (void *)result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8536   float arg2 ;
8537
8538   arg1 = (Dali::Vector4 *)jarg1;
8539   arg2 = (float)jarg2;
8540   if (arg1) (arg1)->x = arg2;
8541 }
8542
8543
8544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8545   float jresult ;
8546   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8547   float result;
8548
8549   arg1 = (Dali::Vector4 *)jarg1;
8550   result = (float) ((arg1)->x);
8551   jresult = result;
8552   return jresult;
8553 }
8554
8555
8556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8557   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8558   float arg2 ;
8559
8560   arg1 = (Dali::Vector4 *)jarg1;
8561   arg2 = (float)jarg2;
8562   if (arg1) (arg1)->r = arg2;
8563 }
8564
8565
8566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8567   float jresult ;
8568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8569   float result;
8570
8571   arg1 = (Dali::Vector4 *)jarg1;
8572   result = (float) ((arg1)->r);
8573   jresult = result;
8574   return jresult;
8575 }
8576
8577
8578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8580   float arg2 ;
8581
8582   arg1 = (Dali::Vector4 *)jarg1;
8583   arg2 = (float)jarg2;
8584   if (arg1) (arg1)->s = arg2;
8585 }
8586
8587
8588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8589   float jresult ;
8590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8591   float result;
8592
8593   arg1 = (Dali::Vector4 *)jarg1;
8594   result = (float) ((arg1)->s);
8595   jresult = result;
8596   return jresult;
8597 }
8598
8599
8600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8602   float arg2 ;
8603
8604   arg1 = (Dali::Vector4 *)jarg1;
8605   arg2 = (float)jarg2;
8606   if (arg1) (arg1)->y = arg2;
8607 }
8608
8609
8610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8611   float jresult ;
8612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8613   float result;
8614
8615   arg1 = (Dali::Vector4 *)jarg1;
8616   result = (float) ((arg1)->y);
8617   jresult = result;
8618   return jresult;
8619 }
8620
8621
8622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8624   float arg2 ;
8625
8626   arg1 = (Dali::Vector4 *)jarg1;
8627   arg2 = (float)jarg2;
8628   if (arg1) (arg1)->g = arg2;
8629 }
8630
8631
8632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8633   float jresult ;
8634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8635   float result;
8636
8637   arg1 = (Dali::Vector4 *)jarg1;
8638   result = (float) ((arg1)->g);
8639   jresult = result;
8640   return jresult;
8641 }
8642
8643
8644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8646   float arg2 ;
8647
8648   arg1 = (Dali::Vector4 *)jarg1;
8649   arg2 = (float)jarg2;
8650   if (arg1) (arg1)->t = arg2;
8651 }
8652
8653
8654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8655   float jresult ;
8656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8657   float result;
8658
8659   arg1 = (Dali::Vector4 *)jarg1;
8660   result = (float) ((arg1)->t);
8661   jresult = result;
8662   return jresult;
8663 }
8664
8665
8666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8668   float arg2 ;
8669
8670   arg1 = (Dali::Vector4 *)jarg1;
8671   arg2 = (float)jarg2;
8672   if (arg1) (arg1)->z = arg2;
8673 }
8674
8675
8676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8677   float jresult ;
8678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8679   float result;
8680
8681   arg1 = (Dali::Vector4 *)jarg1;
8682   result = (float) ((arg1)->z);
8683   jresult = result;
8684   return jresult;
8685 }
8686
8687
8688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8690   float arg2 ;
8691
8692   arg1 = (Dali::Vector4 *)jarg1;
8693   arg2 = (float)jarg2;
8694   if (arg1) (arg1)->b = arg2;
8695 }
8696
8697
8698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8699   float jresult ;
8700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8701   float result;
8702
8703   arg1 = (Dali::Vector4 *)jarg1;
8704   result = (float) ((arg1)->b);
8705   jresult = result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8712   float arg2 ;
8713
8714   arg1 = (Dali::Vector4 *)jarg1;
8715   arg2 = (float)jarg2;
8716   if (arg1) (arg1)->p = arg2;
8717 }
8718
8719
8720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8721   float jresult ;
8722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8723   float result;
8724
8725   arg1 = (Dali::Vector4 *)jarg1;
8726   result = (float) ((arg1)->p);
8727   jresult = result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8734   float arg2 ;
8735
8736   arg1 = (Dali::Vector4 *)jarg1;
8737   arg2 = (float)jarg2;
8738   if (arg1) (arg1)->w = arg2;
8739 }
8740
8741
8742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8743   float jresult ;
8744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8745   float result;
8746
8747   arg1 = (Dali::Vector4 *)jarg1;
8748   result = (float) ((arg1)->w);
8749   jresult = result;
8750   return jresult;
8751 }
8752
8753
8754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8756   float arg2 ;
8757
8758   arg1 = (Dali::Vector4 *)jarg1;
8759   arg2 = (float)jarg2;
8760   if (arg1) (arg1)->a = arg2;
8761 }
8762
8763
8764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8765   float jresult ;
8766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8767   float result;
8768
8769   arg1 = (Dali::Vector4 *)jarg1;
8770   result = (float) ((arg1)->a);
8771   jresult = result;
8772   return jresult;
8773 }
8774
8775
8776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8778   float arg2 ;
8779
8780   arg1 = (Dali::Vector4 *)jarg1;
8781   arg2 = (float)jarg2;
8782   if (arg1) (arg1)->q = arg2;
8783 }
8784
8785
8786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8787   float jresult ;
8788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8789   float result;
8790
8791   arg1 = (Dali::Vector4 *)jarg1;
8792   result = (float) ((arg1)->q);
8793   jresult = result;
8794   return jresult;
8795 }
8796
8797
8798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8800
8801   arg1 = (Dali::Vector4 *)jarg1;
8802   {
8803     try {
8804       delete arg1;
8805     } catch (std::out_of_range& e) {
8806       {
8807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8808       };
8809     } catch (std::exception& e) {
8810       {
8811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8812       };
8813     } catch (Dali::DaliException e) {
8814       {
8815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8816       };
8817     } catch (...) {
8818       {
8819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8820       };
8821     }
8822   }
8823
8824 }
8825
8826
8827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8828   void * jresult ;
8829   Dali::Vector4 *arg1 = 0 ;
8830   Dali::Vector4 *arg2 = 0 ;
8831   Dali::Vector4 result;
8832
8833   arg1 = (Dali::Vector4 *)jarg1;
8834   if (!arg1) {
8835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8836     return 0;
8837   }
8838   arg2 = (Dali::Vector4 *)jarg2;
8839   if (!arg2) {
8840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8841     return 0;
8842   }
8843   {
8844     try {
8845       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8846     } catch (std::out_of_range& e) {
8847       {
8848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (std::exception& e) {
8851       {
8852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8853       };
8854     } catch (Dali::DaliException e) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8857       };
8858     } catch (...) {
8859       {
8860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8861       };
8862     }
8863   }
8864
8865   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8866   return jresult;
8867 }
8868
8869
8870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8871   void * jresult ;
8872   Dali::Vector4 *arg1 = 0 ;
8873   Dali::Vector4 *arg2 = 0 ;
8874   Dali::Vector4 result;
8875
8876   arg1 = (Dali::Vector4 *)jarg1;
8877   if (!arg1) {
8878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8879     return 0;
8880   }
8881   arg2 = (Dali::Vector4 *)jarg2;
8882   if (!arg2) {
8883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8884     return 0;
8885   }
8886   {
8887     try {
8888       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8889     } catch (std::out_of_range& e) {
8890       {
8891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (std::exception& e) {
8894       {
8895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8896       };
8897     } catch (Dali::DaliException e) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8900       };
8901     } catch (...) {
8902       {
8903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8904       };
8905     }
8906   }
8907
8908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8909   return jresult;
8910 }
8911
8912
8913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8914   void * jresult ;
8915   Dali::Vector4 *arg1 = 0 ;
8916   float *arg2 = 0 ;
8917   float *arg3 = 0 ;
8918   float temp2 ;
8919   float temp3 ;
8920   Dali::Vector4 result;
8921
8922   arg1 = (Dali::Vector4 *)jarg1;
8923   if (!arg1) {
8924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8925     return 0;
8926   }
8927   temp2 = (float)jarg2;
8928   arg2 = &temp2;
8929   temp3 = (float)jarg3;
8930   arg3 = &temp3;
8931   {
8932     try {
8933       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8934     } catch (std::out_of_range& e) {
8935       {
8936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (std::exception& e) {
8939       {
8940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8941       };
8942     } catch (Dali::DaliException e) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8945       };
8946     } catch (...) {
8947       {
8948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8949       };
8950     }
8951   }
8952
8953   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8954   return jresult;
8955 }
8956
8957
8958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8959   void * jresult ;
8960   Dali::Uint16Pair *result = 0 ;
8961
8962   {
8963     try {
8964       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8965     } catch (std::out_of_range& e) {
8966       {
8967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (std::exception& e) {
8970       {
8971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (Dali::DaliException e) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8976       };
8977     } catch (...) {
8978       {
8979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8980       };
8981     }
8982   }
8983
8984   jresult = (void *)result;
8985   return jresult;
8986 }
8987
8988
8989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8990   void * jresult ;
8991   uint32_t arg1 ;
8992   uint32_t arg2 ;
8993   Dali::Uint16Pair *result = 0 ;
8994
8995   arg1 = (uint32_t)jarg1;
8996   arg2 = (uint32_t)jarg2;
8997   {
8998     try {
8999       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9000     } catch (std::out_of_range& e) {
9001       {
9002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9003       };
9004     } catch (std::exception& e) {
9005       {
9006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9007       };
9008     } catch (Dali::DaliException e) {
9009       {
9010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9011       };
9012     } catch (...) {
9013       {
9014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9015       };
9016     }
9017   }
9018
9019   jresult = (void *)result;
9020   return jresult;
9021 }
9022
9023
9024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9025   void * jresult ;
9026   Dali::Uint16Pair *arg1 = 0 ;
9027   Dali::Uint16Pair *result = 0 ;
9028
9029   arg1 = (Dali::Uint16Pair *)jarg1;
9030   if (!arg1) {
9031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9032     return 0;
9033   }
9034   {
9035     try {
9036       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9037     } catch (std::out_of_range& e) {
9038       {
9039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9040       };
9041     } catch (std::exception& e) {
9042       {
9043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9044       };
9045     } catch (Dali::DaliException e) {
9046       {
9047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9048       };
9049     } catch (...) {
9050       {
9051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9052       };
9053     }
9054   }
9055
9056   jresult = (void *)result;
9057   return jresult;
9058 }
9059
9060
9061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9062   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9063   uint16_t arg2 ;
9064
9065   arg1 = (Dali::Uint16Pair *)jarg1;
9066   arg2 = (uint16_t)jarg2;
9067   {
9068     try {
9069       (arg1)->SetWidth(arg2);
9070     } catch (std::out_of_range& e) {
9071       {
9072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9073       };
9074     } catch (std::exception& e) {
9075       {
9076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9077       };
9078     } catch (Dali::DaliException e) {
9079       {
9080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9081       };
9082     } catch (...) {
9083       {
9084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9085       };
9086     }
9087   }
9088
9089 }
9090
9091
9092 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9093   unsigned short jresult ;
9094   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9095   uint16_t result;
9096
9097   arg1 = (Dali::Uint16Pair *)jarg1;
9098   {
9099     try {
9100       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9101     } catch (std::out_of_range& e) {
9102       {
9103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9104       };
9105     } catch (std::exception& e) {
9106       {
9107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9108       };
9109     } catch (Dali::DaliException e) {
9110       {
9111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9112       };
9113     } catch (...) {
9114       {
9115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9116       };
9117     }
9118   }
9119
9120   jresult = result;
9121   return jresult;
9122 }
9123
9124
9125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9126   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9127   uint16_t arg2 ;
9128
9129   arg1 = (Dali::Uint16Pair *)jarg1;
9130   arg2 = (uint16_t)jarg2;
9131   {
9132     try {
9133       (arg1)->SetHeight(arg2);
9134     } catch (std::out_of_range& e) {
9135       {
9136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9137       };
9138     } catch (std::exception& e) {
9139       {
9140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9141       };
9142     } catch (Dali::DaliException e) {
9143       {
9144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9145       };
9146     } catch (...) {
9147       {
9148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9149       };
9150     }
9151   }
9152
9153 }
9154
9155
9156 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9157   unsigned short jresult ;
9158   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9159   uint16_t result;
9160
9161   arg1 = (Dali::Uint16Pair *)jarg1;
9162   {
9163     try {
9164       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9165     } catch (std::out_of_range& e) {
9166       {
9167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9168       };
9169     } catch (std::exception& e) {
9170       {
9171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9172       };
9173     } catch (Dali::DaliException e) {
9174       {
9175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9176       };
9177     } catch (...) {
9178       {
9179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9180       };
9181     }
9182   }
9183
9184   jresult = result;
9185   return jresult;
9186 }
9187
9188
9189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9190   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9191   uint16_t arg2 ;
9192
9193   arg1 = (Dali::Uint16Pair *)jarg1;
9194   arg2 = (uint16_t)jarg2;
9195   {
9196     try {
9197       (arg1)->SetX(arg2);
9198     } catch (std::out_of_range& e) {
9199       {
9200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9201       };
9202     } catch (std::exception& e) {
9203       {
9204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9205       };
9206     } catch (Dali::DaliException e) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9209       };
9210     } catch (...) {
9211       {
9212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9213       };
9214     }
9215   }
9216
9217 }
9218
9219
9220 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9221   unsigned short jresult ;
9222   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9223   uint16_t result;
9224
9225   arg1 = (Dali::Uint16Pair *)jarg1;
9226   {
9227     try {
9228       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9229     } catch (std::out_of_range& e) {
9230       {
9231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (std::exception& e) {
9234       {
9235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9236       };
9237     } catch (Dali::DaliException e) {
9238       {
9239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9240       };
9241     } catch (...) {
9242       {
9243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9244       };
9245     }
9246   }
9247
9248   jresult = result;
9249   return jresult;
9250 }
9251
9252
9253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9254   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9255   uint16_t arg2 ;
9256
9257   arg1 = (Dali::Uint16Pair *)jarg1;
9258   arg2 = (uint16_t)jarg2;
9259   {
9260     try {
9261       (arg1)->SetY(arg2);
9262     } catch (std::out_of_range& e) {
9263       {
9264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9265       };
9266     } catch (std::exception& e) {
9267       {
9268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9269       };
9270     } catch (Dali::DaliException e) {
9271       {
9272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9273       };
9274     } catch (...) {
9275       {
9276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9277       };
9278     }
9279   }
9280
9281 }
9282
9283
9284 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9285   unsigned short jresult ;
9286   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9287   uint16_t result;
9288
9289   arg1 = (Dali::Uint16Pair *)jarg1;
9290   {
9291     try {
9292       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9293     } catch (std::out_of_range& e) {
9294       {
9295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9296       };
9297     } catch (std::exception& e) {
9298       {
9299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9300       };
9301     } catch (Dali::DaliException e) {
9302       {
9303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9304       };
9305     } catch (...) {
9306       {
9307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9308       };
9309     }
9310   }
9311
9312   jresult = result;
9313   return jresult;
9314 }
9315
9316
9317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9318   void * jresult ;
9319   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9320   Dali::Uint16Pair *arg2 = 0 ;
9321   Dali::Uint16Pair *result = 0 ;
9322
9323   arg1 = (Dali::Uint16Pair *)jarg1;
9324   arg2 = (Dali::Uint16Pair *)jarg2;
9325   if (!arg2) {
9326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9327     return 0;
9328   }
9329   {
9330     try {
9331       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9332     } catch (std::out_of_range& e) {
9333       {
9334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9335       };
9336     } catch (std::exception& e) {
9337       {
9338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9339       };
9340     } catch (Dali::DaliException e) {
9341       {
9342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9343       };
9344     } catch (...) {
9345       {
9346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9347       };
9348     }
9349   }
9350
9351   jresult = (void *)result;
9352   return jresult;
9353 }
9354
9355
9356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9357   unsigned int jresult ;
9358   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9359   Dali::Uint16Pair *arg2 = 0 ;
9360   bool result;
9361
9362   arg1 = (Dali::Uint16Pair *)jarg1;
9363   arg2 = (Dali::Uint16Pair *)jarg2;
9364   if (!arg2) {
9365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9366     return 0;
9367   }
9368   {
9369     try {
9370       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9371     } catch (std::out_of_range& e) {
9372       {
9373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9374       };
9375     } catch (std::exception& e) {
9376       {
9377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9378       };
9379     } catch (Dali::DaliException e) {
9380       {
9381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9382       };
9383     } catch (...) {
9384       {
9385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9386       };
9387     }
9388   }
9389
9390   jresult = result;
9391   return jresult;
9392 }
9393
9394
9395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9396   unsigned int jresult ;
9397   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9398   Dali::Uint16Pair *arg2 = 0 ;
9399   bool result;
9400
9401   arg1 = (Dali::Uint16Pair *)jarg1;
9402   arg2 = (Dali::Uint16Pair *)jarg2;
9403   if (!arg2) {
9404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9405     return 0;
9406   }
9407   {
9408     try {
9409       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (Dali::DaliException e) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9421       };
9422     } catch (...) {
9423       {
9424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9425       };
9426     }
9427   }
9428
9429   jresult = result;
9430   return jresult;
9431 }
9432
9433
9434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9435   unsigned int jresult ;
9436   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9437   Dali::Uint16Pair *arg2 = 0 ;
9438   bool result;
9439
9440   arg1 = (Dali::Uint16Pair *)jarg1;
9441   arg2 = (Dali::Uint16Pair *)jarg2;
9442   if (!arg2) {
9443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9444     return 0;
9445   }
9446   {
9447     try {
9448       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9449     } catch (std::out_of_range& e) {
9450       {
9451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9452       };
9453     } catch (std::exception& e) {
9454       {
9455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9456       };
9457     } catch (Dali::DaliException e) {
9458       {
9459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9460       };
9461     } catch (...) {
9462       {
9463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9464       };
9465     }
9466   }
9467
9468   jresult = result;
9469   return jresult;
9470 }
9471
9472
9473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9474   unsigned int jresult ;
9475   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9476   Dali::Uint16Pair *arg2 = 0 ;
9477   bool result;
9478
9479   arg1 = (Dali::Uint16Pair *)jarg1;
9480   arg2 = (Dali::Uint16Pair *)jarg2;
9481   if (!arg2) {
9482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9483     return 0;
9484   }
9485   {
9486     try {
9487       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9488     } catch (std::out_of_range& e) {
9489       {
9490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9491       };
9492     } catch (std::exception& e) {
9493       {
9494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9495       };
9496     } catch (Dali::DaliException e) {
9497       {
9498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9499       };
9500     } catch (...) {
9501       {
9502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9503       };
9504     }
9505   }
9506
9507   jresult = result;
9508   return jresult;
9509 }
9510
9511
9512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9513   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9514
9515   arg1 = (Dali::Uint16Pair *)jarg1;
9516   {
9517     try {
9518       delete arg1;
9519     } catch (std::out_of_range& e) {
9520       {
9521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9522       };
9523     } catch (std::exception& e) {
9524       {
9525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9526       };
9527     } catch (Dali::DaliException e) {
9528       {
9529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9530       };
9531     } catch (...) {
9532       {
9533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9534       };
9535     }
9536   }
9537
9538 }
9539
9540
9541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9542   void * jresult ;
9543   Dali::Degree *result = 0 ;
9544
9545   {
9546     try {
9547       result = (Dali::Degree *)new Dali::Degree();
9548     } catch (std::out_of_range& e) {
9549       {
9550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9551       };
9552     } catch (std::exception& e) {
9553       {
9554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9555       };
9556     } catch (Dali::DaliException e) {
9557       {
9558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9559       };
9560     } catch (...) {
9561       {
9562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9563       };
9564     }
9565   }
9566
9567   jresult = (void *)result;
9568   return jresult;
9569 }
9570
9571
9572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9573   void * jresult ;
9574   float arg1 ;
9575   Dali::Degree *result = 0 ;
9576
9577   arg1 = (float)jarg1;
9578   {
9579     try {
9580       result = (Dali::Degree *)new Dali::Degree(arg1);
9581     } catch (std::out_of_range& e) {
9582       {
9583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9584       };
9585     } catch (std::exception& e) {
9586       {
9587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9588       };
9589     } catch (Dali::DaliException e) {
9590       {
9591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9592       };
9593     } catch (...) {
9594       {
9595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9596       };
9597     }
9598   }
9599
9600   jresult = (void *)result;
9601   return jresult;
9602 }
9603
9604
9605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9606   void * jresult ;
9607   Dali::Radian arg1 ;
9608   Dali::Radian *argp1 ;
9609   Dali::Degree *result = 0 ;
9610
9611   argp1 = (Dali::Radian *)jarg1;
9612   if (!argp1) {
9613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9614     return 0;
9615   }
9616   arg1 = *argp1;
9617   {
9618     try {
9619       result = (Dali::Degree *)new Dali::Degree(arg1);
9620     } catch (std::out_of_range& e) {
9621       {
9622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (std::exception& e) {
9625       {
9626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9627       };
9628     } catch (Dali::DaliException e) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9631       };
9632     } catch (...) {
9633       {
9634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9635       };
9636     }
9637   }
9638
9639   jresult = (void *)result;
9640   return jresult;
9641 }
9642
9643
9644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9645   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9646   float arg2 ;
9647
9648   arg1 = (Dali::Degree *)jarg1;
9649   arg2 = (float)jarg2;
9650   if (arg1) (arg1)->degree = arg2;
9651 }
9652
9653
9654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9655   float jresult ;
9656   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9657   float result;
9658
9659   arg1 = (Dali::Degree *)jarg1;
9660   result = (float) ((arg1)->degree);
9661   jresult = result;
9662   return jresult;
9663 }
9664
9665
9666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9667   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9668
9669   arg1 = (Dali::Degree *)jarg1;
9670   {
9671     try {
9672       delete arg1;
9673     } catch (std::out_of_range& e) {
9674       {
9675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9676       };
9677     } catch (std::exception& e) {
9678       {
9679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9680       };
9681     } catch (Dali::DaliException e) {
9682       {
9683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9684       };
9685     } catch (...) {
9686       {
9687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9688       };
9689     }
9690   }
9691
9692 }
9693
9694
9695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9696   void * jresult ;
9697   Dali::Radian *result = 0 ;
9698
9699   result = (Dali::Radian *)&Dali::ANGLE_360;
9700   jresult = (void *)result;
9701   return jresult;
9702 }
9703
9704
9705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9706   void * jresult ;
9707   Dali::Radian *result = 0 ;
9708
9709   result = (Dali::Radian *)&Dali::ANGLE_315;
9710   jresult = (void *)result;
9711   return jresult;
9712 }
9713
9714
9715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9716   void * jresult ;
9717   Dali::Radian *result = 0 ;
9718
9719   result = (Dali::Radian *)&Dali::ANGLE_270;
9720   jresult = (void *)result;
9721   return jresult;
9722 }
9723
9724
9725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9726   void * jresult ;
9727   Dali::Radian *result = 0 ;
9728
9729   result = (Dali::Radian *)&Dali::ANGLE_225;
9730   jresult = (void *)result;
9731   return jresult;
9732 }
9733
9734
9735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9736   void * jresult ;
9737   Dali::Radian *result = 0 ;
9738
9739   result = (Dali::Radian *)&Dali::ANGLE_180;
9740   jresult = (void *)result;
9741   return jresult;
9742 }
9743
9744
9745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9746   void * jresult ;
9747   Dali::Radian *result = 0 ;
9748
9749   result = (Dali::Radian *)&Dali::ANGLE_135;
9750   jresult = (void *)result;
9751   return jresult;
9752 }
9753
9754
9755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9756   void * jresult ;
9757   Dali::Radian *result = 0 ;
9758
9759   result = (Dali::Radian *)&Dali::ANGLE_120;
9760   jresult = (void *)result;
9761   return jresult;
9762 }
9763
9764
9765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9766   void * jresult ;
9767   Dali::Radian *result = 0 ;
9768
9769   result = (Dali::Radian *)&Dali::ANGLE_90;
9770   jresult = (void *)result;
9771   return jresult;
9772 }
9773
9774
9775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9776   void * jresult ;
9777   Dali::Radian *result = 0 ;
9778
9779   result = (Dali::Radian *)&Dali::ANGLE_60;
9780   jresult = (void *)result;
9781   return jresult;
9782 }
9783
9784
9785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9786   void * jresult ;
9787   Dali::Radian *result = 0 ;
9788
9789   result = (Dali::Radian *)&Dali::ANGLE_45;
9790   jresult = (void *)result;
9791   return jresult;
9792 }
9793
9794
9795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9796   void * jresult ;
9797   Dali::Radian *result = 0 ;
9798
9799   result = (Dali::Radian *)&Dali::ANGLE_30;
9800   jresult = (void *)result;
9801   return jresult;
9802 }
9803
9804
9805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9806   void * jresult ;
9807   Dali::Radian *result = 0 ;
9808
9809   result = (Dali::Radian *)&Dali::ANGLE_0;
9810   jresult = (void *)result;
9811   return jresult;
9812 }
9813
9814
9815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9816   unsigned int jresult ;
9817   Dali::Degree *arg1 = 0 ;
9818   Dali::Degree *arg2 = 0 ;
9819   bool result;
9820
9821   arg1 = (Dali::Degree *)jarg1;
9822   if (!arg1) {
9823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9824     return 0;
9825   }
9826   arg2 = (Dali::Degree *)jarg2;
9827   if (!arg2) {
9828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9829     return 0;
9830   }
9831   {
9832     try {
9833       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9834     } catch (std::out_of_range& e) {
9835       {
9836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (std::exception& e) {
9839       {
9840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9841       };
9842     } catch (Dali::DaliException e) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9845       };
9846     } catch (...) {
9847       {
9848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9849       };
9850     }
9851   }
9852
9853   jresult = result;
9854   return jresult;
9855 }
9856
9857
9858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9859   unsigned int jresult ;
9860   Dali::Degree *arg1 = 0 ;
9861   Dali::Degree *arg2 = 0 ;
9862   bool result;
9863
9864   arg1 = (Dali::Degree *)jarg1;
9865   if (!arg1) {
9866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9867     return 0;
9868   }
9869   arg2 = (Dali::Degree *)jarg2;
9870   if (!arg2) {
9871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9872     return 0;
9873   }
9874   {
9875     try {
9876       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9877     } catch (std::out_of_range& e) {
9878       {
9879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9880       };
9881     } catch (std::exception& e) {
9882       {
9883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9884       };
9885     } catch (Dali::DaliException e) {
9886       {
9887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9888       };
9889     } catch (...) {
9890       {
9891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9892       };
9893     }
9894   }
9895
9896   jresult = result;
9897   return jresult;
9898 }
9899
9900
9901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9902   void * jresult ;
9903   Dali::Degree arg1 ;
9904   float arg2 ;
9905   float arg3 ;
9906   Dali::Degree *argp1 ;
9907   Dali::Degree result;
9908
9909   argp1 = (Dali::Degree *)jarg1;
9910   if (!argp1) {
9911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9912     return 0;
9913   }
9914   arg1 = *argp1;
9915   arg2 = (float)jarg2;
9916   arg3 = (float)jarg3;
9917   {
9918     try {
9919       result = Dali::Clamp(arg1,arg2,arg3);
9920     } catch (std::out_of_range& e) {
9921       {
9922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (std::exception& e) {
9925       {
9926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9927       };
9928     } catch (Dali::DaliException e) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9931       };
9932     } catch (...) {
9933       {
9934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9935       };
9936     }
9937   }
9938
9939   jresult = new Dali::Degree((const Dali::Degree &)result);
9940   return jresult;
9941 }
9942
9943
9944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9945   void * jresult ;
9946   Dali::Radian *result = 0 ;
9947
9948   {
9949     try {
9950       result = (Dali::Radian *)new Dali::Radian();
9951     } catch (std::out_of_range& e) {
9952       {
9953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9954       };
9955     } catch (std::exception& e) {
9956       {
9957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9958       };
9959     } catch (Dali::DaliException e) {
9960       {
9961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9962       };
9963     } catch (...) {
9964       {
9965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9966       };
9967     }
9968   }
9969
9970   jresult = (void *)result;
9971   return jresult;
9972 }
9973
9974
9975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9976   void * jresult ;
9977   float arg1 ;
9978   Dali::Radian *result = 0 ;
9979
9980   arg1 = (float)jarg1;
9981   {
9982     try {
9983       result = (Dali::Radian *)new Dali::Radian(arg1);
9984     } catch (std::out_of_range& e) {
9985       {
9986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9987       };
9988     } catch (std::exception& e) {
9989       {
9990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9991       };
9992     } catch (Dali::DaliException e) {
9993       {
9994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9995       };
9996     } catch (...) {
9997       {
9998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9999       };
10000     }
10001   }
10002
10003   jresult = (void *)result;
10004   return jresult;
10005 }
10006
10007
10008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10009   void * jresult ;
10010   Dali::Degree arg1 ;
10011   Dali::Degree *argp1 ;
10012   Dali::Radian *result = 0 ;
10013
10014   argp1 = (Dali::Degree *)jarg1;
10015   if (!argp1) {
10016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10017     return 0;
10018   }
10019   arg1 = *argp1;
10020   {
10021     try {
10022       result = (Dali::Radian *)new Dali::Radian(arg1);
10023     } catch (std::out_of_range& e) {
10024       {
10025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10026       };
10027     } catch (std::exception& e) {
10028       {
10029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10030       };
10031     } catch (Dali::DaliException e) {
10032       {
10033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10034       };
10035     } catch (...) {
10036       {
10037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10038       };
10039     }
10040   }
10041
10042   jresult = (void *)result;
10043   return jresult;
10044 }
10045
10046
10047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10048   void * jresult ;
10049   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10050   float arg2 ;
10051   Dali::Radian *result = 0 ;
10052
10053   arg1 = (Dali::Radian *)jarg1;
10054   arg2 = (float)jarg2;
10055   {
10056     try {
10057       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10058     } catch (std::out_of_range& e) {
10059       {
10060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (std::exception& e) {
10063       {
10064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10065       };
10066     } catch (Dali::DaliException e) {
10067       {
10068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10069       };
10070     } catch (...) {
10071       {
10072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10073       };
10074     }
10075   }
10076
10077   jresult = (void *)result;
10078   return jresult;
10079 }
10080
10081
10082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10083   void * jresult ;
10084   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10085   Dali::Degree arg2 ;
10086   Dali::Degree *argp2 ;
10087   Dali::Radian *result = 0 ;
10088
10089   arg1 = (Dali::Radian *)jarg1;
10090   argp2 = (Dali::Degree *)jarg2;
10091   if (!argp2) {
10092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10093     return 0;
10094   }
10095   arg2 = *argp2;
10096   {
10097     try {
10098       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10099     } catch (std::out_of_range& e) {
10100       {
10101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10102       };
10103     } catch (std::exception& e) {
10104       {
10105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10106       };
10107     } catch (Dali::DaliException e) {
10108       {
10109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10110       };
10111     } catch (...) {
10112       {
10113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10114       };
10115     }
10116   }
10117
10118   jresult = (void *)result;
10119   return jresult;
10120 }
10121
10122
10123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10124   float jresult ;
10125   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10126   float result;
10127
10128   arg1 = (Dali::Radian *)jarg1;
10129   {
10130     try {
10131       result = (float)((Dali::Radian const *)arg1)->operator float();
10132     } catch (std::out_of_range& e) {
10133       {
10134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10135       };
10136     } catch (std::exception& e) {
10137       {
10138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10139       };
10140     } catch (Dali::DaliException e) {
10141       {
10142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10143       };
10144     } catch (...) {
10145       {
10146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10147       };
10148     }
10149   }
10150
10151   jresult = result;
10152   return jresult;
10153 }
10154
10155
10156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10157   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10158   float arg2 ;
10159
10160   arg1 = (Dali::Radian *)jarg1;
10161   arg2 = (float)jarg2;
10162   if (arg1) (arg1)->radian = arg2;
10163 }
10164
10165
10166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10167   float jresult ;
10168   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10169   float result;
10170
10171   arg1 = (Dali::Radian *)jarg1;
10172   result = (float) ((arg1)->radian);
10173   jresult = result;
10174   return jresult;
10175 }
10176
10177
10178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10179   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10180
10181   arg1 = (Dali::Radian *)jarg1;
10182   {
10183     try {
10184       delete arg1;
10185     } catch (std::out_of_range& e) {
10186       {
10187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10188       };
10189     } catch (std::exception& e) {
10190       {
10191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10192       };
10193     } catch (Dali::DaliException e) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10196       };
10197     } catch (...) {
10198       {
10199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10200       };
10201     }
10202   }
10203
10204 }
10205
10206
10207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10208   unsigned int jresult ;
10209   Dali::Radian arg1 ;
10210   Dali::Radian arg2 ;
10211   Dali::Radian *argp1 ;
10212   Dali::Radian *argp2 ;
10213   bool result;
10214
10215   argp1 = (Dali::Radian *)jarg1;
10216   if (!argp1) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg1 = *argp1;
10221   argp2 = (Dali::Radian *)jarg2;
10222   if (!argp2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10224     return 0;
10225   }
10226   arg2 = *argp2;
10227   {
10228     try {
10229       result = (bool)Dali::operator ==(arg1,arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (Dali::DaliException e) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10241       };
10242     } catch (...) {
10243       {
10244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10245       };
10246     }
10247   }
10248
10249   jresult = result;
10250   return jresult;
10251 }
10252
10253
10254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10255   unsigned int jresult ;
10256   Dali::Radian arg1 ;
10257   Dali::Radian arg2 ;
10258   Dali::Radian *argp1 ;
10259   Dali::Radian *argp2 ;
10260   bool result;
10261
10262   argp1 = (Dali::Radian *)jarg1;
10263   if (!argp1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10265     return 0;
10266   }
10267   arg1 = *argp1;
10268   argp2 = (Dali::Radian *)jarg2;
10269   if (!argp2) {
10270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10271     return 0;
10272   }
10273   arg2 = *argp2;
10274   {
10275     try {
10276       result = (bool)Dali::operator !=(arg1,arg2);
10277     } catch (std::out_of_range& e) {
10278       {
10279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (std::exception& e) {
10282       {
10283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10284       };
10285     } catch (Dali::DaliException e) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10288       };
10289     } catch (...) {
10290       {
10291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10292       };
10293     }
10294   }
10295
10296   jresult = result;
10297   return jresult;
10298 }
10299
10300
10301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10302   unsigned int jresult ;
10303   Dali::Radian arg1 ;
10304   Dali::Degree arg2 ;
10305   Dali::Radian *argp1 ;
10306   Dali::Degree *argp2 ;
10307   bool result;
10308
10309   argp1 = (Dali::Radian *)jarg1;
10310   if (!argp1) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10312     return 0;
10313   }
10314   arg1 = *argp1;
10315   argp2 = (Dali::Degree *)jarg2;
10316   if (!argp2) {
10317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10318     return 0;
10319   }
10320   arg2 = *argp2;
10321   {
10322     try {
10323       result = (bool)Dali::operator ==(arg1,arg2);
10324     } catch (std::out_of_range& e) {
10325       {
10326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (std::exception& e) {
10329       {
10330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (Dali::DaliException e) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342
10343   jresult = result;
10344   return jresult;
10345 }
10346
10347
10348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10349   unsigned int jresult ;
10350   Dali::Radian arg1 ;
10351   Dali::Degree arg2 ;
10352   Dali::Radian *argp1 ;
10353   Dali::Degree *argp2 ;
10354   bool result;
10355
10356   argp1 = (Dali::Radian *)jarg1;
10357   if (!argp1) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10359     return 0;
10360   }
10361   arg1 = *argp1;
10362   argp2 = (Dali::Degree *)jarg2;
10363   if (!argp2) {
10364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10365     return 0;
10366   }
10367   arg2 = *argp2;
10368   {
10369     try {
10370       result = (bool)Dali::operator !=(arg1,arg2);
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (Dali::DaliException e) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10382       };
10383     } catch (...) {
10384       {
10385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10386       };
10387     }
10388   }
10389
10390   jresult = result;
10391   return jresult;
10392 }
10393
10394
10395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10396   unsigned int jresult ;
10397   Dali::Degree arg1 ;
10398   Dali::Radian arg2 ;
10399   Dali::Degree *argp1 ;
10400   Dali::Radian *argp2 ;
10401   bool result;
10402
10403   argp1 = (Dali::Degree *)jarg1;
10404   if (!argp1) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10406     return 0;
10407   }
10408   arg1 = *argp1;
10409   argp2 = (Dali::Radian *)jarg2;
10410   if (!argp2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10412     return 0;
10413   }
10414   arg2 = *argp2;
10415   {
10416     try {
10417       result = (bool)Dali::operator ==(arg1,arg2);
10418     } catch (std::out_of_range& e) {
10419       {
10420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (std::exception& e) {
10423       {
10424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10425       };
10426     } catch (Dali::DaliException e) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10429       };
10430     } catch (...) {
10431       {
10432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10433       };
10434     }
10435   }
10436
10437   jresult = result;
10438   return jresult;
10439 }
10440
10441
10442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10443   unsigned int jresult ;
10444   Dali::Degree arg1 ;
10445   Dali::Radian arg2 ;
10446   Dali::Degree *argp1 ;
10447   Dali::Radian *argp2 ;
10448   bool result;
10449
10450   argp1 = (Dali::Degree *)jarg1;
10451   if (!argp1) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10453     return 0;
10454   }
10455   arg1 = *argp1;
10456   argp2 = (Dali::Radian *)jarg2;
10457   if (!argp2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10459     return 0;
10460   }
10461   arg2 = *argp2;
10462   {
10463     try {
10464       result = (bool)Dali::operator !=(arg1,arg2);
10465     } catch (std::out_of_range& e) {
10466       {
10467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (std::exception& e) {
10470       {
10471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10472       };
10473     } catch (Dali::DaliException e) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10476       };
10477     } catch (...) {
10478       {
10479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10480       };
10481     }
10482   }
10483
10484   jresult = result;
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10490   unsigned int jresult ;
10491   Dali::Radian arg1 ;
10492   Dali::Radian arg2 ;
10493   Dali::Radian *argp1 ;
10494   Dali::Radian *argp2 ;
10495   bool result;
10496
10497   argp1 = (Dali::Radian *)jarg1;
10498   if (!argp1) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg1 = *argp1;
10503   argp2 = (Dali::Radian *)jarg2;
10504   if (!argp2) {
10505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10506     return 0;
10507   }
10508   arg2 = *argp2;
10509   {
10510     try {
10511       result = (bool)Dali::operator >(arg1,arg2);
10512     } catch (std::out_of_range& e) {
10513       {
10514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (std::exception& e) {
10517       {
10518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10519       };
10520     } catch (Dali::DaliException e) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10523       };
10524     } catch (...) {
10525       {
10526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10527       };
10528     }
10529   }
10530
10531   jresult = result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10537   unsigned int jresult ;
10538   Dali::Radian arg1 ;
10539   Dali::Degree arg2 ;
10540   Dali::Radian *argp1 ;
10541   Dali::Degree *argp2 ;
10542   bool result;
10543
10544   argp1 = (Dali::Radian *)jarg1;
10545   if (!argp1) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10547     return 0;
10548   }
10549   arg1 = *argp1;
10550   argp2 = (Dali::Degree *)jarg2;
10551   if (!argp2) {
10552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10553     return 0;
10554   }
10555   arg2 = *argp2;
10556   {
10557     try {
10558       result = (bool)Dali::operator >(arg1,arg2);
10559     } catch (std::out_of_range& e) {
10560       {
10561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (std::exception& e) {
10564       {
10565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10566       };
10567     } catch (Dali::DaliException e) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10570       };
10571     } catch (...) {
10572       {
10573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10574       };
10575     }
10576   }
10577
10578   jresult = result;
10579   return jresult;
10580 }
10581
10582
10583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10584   unsigned int jresult ;
10585   Dali::Degree arg1 ;
10586   Dali::Radian arg2 ;
10587   Dali::Degree *argp1 ;
10588   Dali::Radian *argp2 ;
10589   bool result;
10590
10591   argp1 = (Dali::Degree *)jarg1;
10592   if (!argp1) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10594     return 0;
10595   }
10596   arg1 = *argp1;
10597   argp2 = (Dali::Radian *)jarg2;
10598   if (!argp2) {
10599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10600     return 0;
10601   }
10602   arg2 = *argp2;
10603   {
10604     try {
10605       result = (bool)Dali::operator >(arg1,arg2);
10606     } catch (std::out_of_range& e) {
10607       {
10608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (std::exception& e) {
10611       {
10612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (Dali::DaliException e) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624
10625   jresult = result;
10626   return jresult;
10627 }
10628
10629
10630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10631   unsigned int jresult ;
10632   Dali::Radian arg1 ;
10633   Dali::Radian arg2 ;
10634   Dali::Radian *argp1 ;
10635   Dali::Radian *argp2 ;
10636   bool result;
10637
10638   argp1 = (Dali::Radian *)jarg1;
10639   if (!argp1) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg1 = *argp1;
10644   argp2 = (Dali::Radian *)jarg2;
10645   if (!argp2) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10647     return 0;
10648   }
10649   arg2 = *argp2;
10650   {
10651     try {
10652       result = (bool)Dali::operator <(arg1,arg2);
10653     } catch (std::out_of_range& e) {
10654       {
10655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (std::exception& e) {
10658       {
10659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10660       };
10661     } catch (Dali::DaliException e) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10664       };
10665     } catch (...) {
10666       {
10667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10668       };
10669     }
10670   }
10671
10672   jresult = result;
10673   return jresult;
10674 }
10675
10676
10677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10678   unsigned int jresult ;
10679   Dali::Radian arg1 ;
10680   Dali::Degree arg2 ;
10681   Dali::Radian *argp1 ;
10682   Dali::Degree *argp2 ;
10683   bool result;
10684
10685   argp1 = (Dali::Radian *)jarg1;
10686   if (!argp1) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10688     return 0;
10689   }
10690   arg1 = *argp1;
10691   argp2 = (Dali::Degree *)jarg2;
10692   if (!argp2) {
10693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10694     return 0;
10695   }
10696   arg2 = *argp2;
10697   {
10698     try {
10699       result = (bool)Dali::operator <(arg1,arg2);
10700     } catch (std::out_of_range& e) {
10701       {
10702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (std::exception& e) {
10705       {
10706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10707       };
10708     } catch (Dali::DaliException e) {
10709       {
10710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10711       };
10712     } catch (...) {
10713       {
10714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10715       };
10716     }
10717   }
10718
10719   jresult = result;
10720   return jresult;
10721 }
10722
10723
10724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10725   unsigned int jresult ;
10726   Dali::Degree arg1 ;
10727   Dali::Radian arg2 ;
10728   Dali::Degree *argp1 ;
10729   Dali::Radian *argp2 ;
10730   bool result;
10731
10732   argp1 = (Dali::Degree *)jarg1;
10733   if (!argp1) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10735     return 0;
10736   }
10737   arg1 = *argp1;
10738   argp2 = (Dali::Radian *)jarg2;
10739   if (!argp2) {
10740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10741     return 0;
10742   }
10743   arg2 = *argp2;
10744   {
10745     try {
10746       result = (bool)Dali::operator <(arg1,arg2);
10747     } catch (std::out_of_range& e) {
10748       {
10749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (std::exception& e) {
10752       {
10753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10754       };
10755     } catch (Dali::DaliException e) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10758       };
10759     } catch (...) {
10760       {
10761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10762       };
10763     }
10764   }
10765
10766   jresult = result;
10767   return jresult;
10768 }
10769
10770
10771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10772   void * jresult ;
10773   Dali::Radian arg1 ;
10774   float arg2 ;
10775   Dali::Radian *argp1 ;
10776   Dali::Radian result;
10777
10778   argp1 = (Dali::Radian *)jarg1;
10779   if (!argp1) {
10780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10781     return 0;
10782   }
10783   arg1 = *argp1;
10784   arg2 = (float)jarg2;
10785   {
10786     try {
10787       result = Dali::operator *(arg1,arg2);
10788     } catch (std::out_of_range& e) {
10789       {
10790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10791       };
10792     } catch (std::exception& e) {
10793       {
10794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10795       };
10796     } catch (Dali::DaliException e) {
10797       {
10798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10799       };
10800     } catch (...) {
10801       {
10802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10803       };
10804     }
10805   }
10806
10807   jresult = new Dali::Radian((const Dali::Radian &)result);
10808   return jresult;
10809 }
10810
10811
10812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10813   void * jresult ;
10814   Dali::Radian arg1 ;
10815   Dali::Radian *argp1 ;
10816   Dali::Radian result;
10817
10818   argp1 = (Dali::Radian *)jarg1;
10819   if (!argp1) {
10820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10821     return 0;
10822   }
10823   arg1 = *argp1;
10824   {
10825     try {
10826       result = Dali::operator -(arg1);
10827     } catch (std::out_of_range& e) {
10828       {
10829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10830       };
10831     } catch (std::exception& e) {
10832       {
10833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10834       };
10835     } catch (Dali::DaliException e) {
10836       {
10837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10838       };
10839     } catch (...) {
10840       {
10841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10842       };
10843     }
10844   }
10845
10846   jresult = new Dali::Radian((const Dali::Radian &)result);
10847   return jresult;
10848 }
10849
10850
10851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10852   void * jresult ;
10853   Dali::Radian arg1 ;
10854   float arg2 ;
10855   float arg3 ;
10856   Dali::Radian *argp1 ;
10857   Dali::Radian result;
10858
10859   argp1 = (Dali::Radian *)jarg1;
10860   if (!argp1) {
10861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10862     return 0;
10863   }
10864   arg1 = *argp1;
10865   arg2 = (float)jarg2;
10866   arg3 = (float)jarg3;
10867   {
10868     try {
10869       result = Dali::Clamp(arg1,arg2,arg3);
10870     } catch (std::out_of_range& e) {
10871       {
10872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (std::exception& e) {
10875       {
10876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10877       };
10878     } catch (Dali::DaliException e) {
10879       {
10880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10881       };
10882     } catch (...) {
10883       {
10884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10885       };
10886     }
10887   }
10888
10889   jresult = new Dali::Radian((const Dali::Radian &)result);
10890   return jresult;
10891 }
10892
10893
10894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10895   void * jresult ;
10896   Dali::Quaternion *result = 0 ;
10897
10898   {
10899     try {
10900       result = (Dali::Quaternion *)new Dali::Quaternion();
10901     } catch (std::out_of_range& e) {
10902       {
10903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (std::exception& e) {
10906       {
10907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10908       };
10909     } catch (Dali::DaliException e) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10912       };
10913     } catch (...) {
10914       {
10915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10916       };
10917     }
10918   }
10919
10920   jresult = (void *)result;
10921   return jresult;
10922 }
10923
10924
10925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10926   void * jresult ;
10927   Dali::Radian arg1 ;
10928   Dali::Vector3 *arg2 = 0 ;
10929   Dali::Radian *argp1 ;
10930   Dali::Quaternion *result = 0 ;
10931
10932   argp1 = (Dali::Radian *)jarg1;
10933   if (!argp1) {
10934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10935     return 0;
10936   }
10937   arg1 = *argp1;
10938   arg2 = (Dali::Vector3 *)jarg2;
10939   if (!arg2) {
10940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10941     return 0;
10942   }
10943   {
10944     try {
10945       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10946     } catch (std::out_of_range& e) {
10947       {
10948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10949       };
10950     } catch (std::exception& e) {
10951       {
10952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10953       };
10954     } catch (Dali::DaliException e) {
10955       {
10956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10957       };
10958     } catch (...) {
10959       {
10960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10961       };
10962     }
10963   }
10964
10965   jresult = (void *)result;
10966   return jresult;
10967 }
10968
10969
10970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10971   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10972
10973   arg1 = (Dali::Quaternion *)jarg1;
10974   {
10975     try {
10976       delete arg1;
10977     } catch (std::out_of_range& e) {
10978       {
10979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10980       };
10981     } catch (std::exception& e) {
10982       {
10983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10984       };
10985     } catch (Dali::DaliException e) {
10986       {
10987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10988       };
10989     } catch (...) {
10990       {
10991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10992       };
10993     }
10994   }
10995
10996 }
10997
10998
10999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11000   void * jresult ;
11001   Dali::Quaternion *result = 0 ;
11002
11003   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11004   jresult = (void *)result;
11005   return jresult;
11006 }
11007
11008
11009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11010   unsigned int jresult ;
11011   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11012   bool result;
11013
11014   arg1 = (Dali::Quaternion *)jarg1;
11015   {
11016     try {
11017       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11018     } catch (std::out_of_range& e) {
11019       {
11020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (std::exception& e) {
11023       {
11024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11025       };
11026     } catch (Dali::DaliException e) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11029       };
11030     } catch (...) {
11031       {
11032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11033       };
11034     }
11035   }
11036
11037   jresult = result;
11038   return jresult;
11039 }
11040
11041
11042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11043   unsigned int jresult ;
11044   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11045   Dali::Vector3 *arg2 = 0 ;
11046   Dali::Radian *arg3 = 0 ;
11047   bool result;
11048
11049   arg1 = (Dali::Quaternion *)jarg1;
11050   arg2 = (Dali::Vector3 *)jarg2;
11051   if (!arg2) {
11052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11053     return 0;
11054   }
11055   arg3 = (Dali::Radian *)jarg3;
11056   if (!arg3) {
11057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11058     return 0;
11059   }
11060   {
11061     try {
11062       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11063     } catch (std::out_of_range& e) {
11064       {
11065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11066       };
11067     } catch (std::exception& e) {
11068       {
11069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11070       };
11071     } catch (Dali::DaliException e) {
11072       {
11073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11074       };
11075     } catch (...) {
11076       {
11077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11078       };
11079     }
11080   }
11081
11082   jresult = result;
11083   return jresult;
11084 }
11085
11086
11087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11088   void * jresult ;
11089   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11090   Dali::Quaternion *arg2 = 0 ;
11091   Dali::Quaternion result;
11092
11093   arg1 = (Dali::Quaternion *)jarg1;
11094   arg2 = (Dali::Quaternion *)jarg2;
11095   if (!arg2) {
11096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11097     return 0;
11098   }
11099   {
11100     try {
11101       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11102     } catch (std::out_of_range& e) {
11103       {
11104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11105       };
11106     } catch (std::exception& e) {
11107       {
11108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11109       };
11110     } catch (Dali::DaliException e) {
11111       {
11112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11113       };
11114     } catch (...) {
11115       {
11116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11117       };
11118     }
11119   }
11120
11121   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11122   return jresult;
11123 }
11124
11125
11126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11127   void * jresult ;
11128   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11129   Dali::Quaternion *arg2 = 0 ;
11130   Dali::Quaternion result;
11131
11132   arg1 = (Dali::Quaternion *)jarg1;
11133   arg2 = (Dali::Quaternion *)jarg2;
11134   if (!arg2) {
11135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11136     return 0;
11137   }
11138   {
11139     try {
11140       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11141     } catch (std::out_of_range& e) {
11142       {
11143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11144       };
11145     } catch (std::exception& e) {
11146       {
11147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11148       };
11149     } catch (Dali::DaliException e) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11152       };
11153     } catch (...) {
11154       {
11155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11156       };
11157     }
11158   }
11159
11160   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11161   return jresult;
11162 }
11163
11164
11165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11166   void * jresult ;
11167   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11168   Dali::Quaternion *arg2 = 0 ;
11169   Dali::Quaternion result;
11170
11171   arg1 = (Dali::Quaternion *)jarg1;
11172   arg2 = (Dali::Quaternion *)jarg2;
11173   if (!arg2) {
11174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11175     return 0;
11176   }
11177   {
11178     try {
11179       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11180     } catch (std::out_of_range& e) {
11181       {
11182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11183       };
11184     } catch (std::exception& e) {
11185       {
11186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11187       };
11188     } catch (Dali::DaliException e) {
11189       {
11190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11191       };
11192     } catch (...) {
11193       {
11194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11195       };
11196     }
11197   }
11198
11199   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11200   return jresult;
11201 }
11202
11203
11204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11205   void * jresult ;
11206   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11207   Dali::Vector3 *arg2 = 0 ;
11208   Dali::Vector3 result;
11209
11210   arg1 = (Dali::Quaternion *)jarg1;
11211   arg2 = (Dali::Vector3 *)jarg2;
11212   if (!arg2) {
11213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11214     return 0;
11215   }
11216   {
11217     try {
11218       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11219     } catch (std::out_of_range& e) {
11220       {
11221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (std::exception& e) {
11224       {
11225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11226       };
11227     } catch (Dali::DaliException e) {
11228       {
11229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11230       };
11231     } catch (...) {
11232       {
11233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11234       };
11235     }
11236   }
11237
11238   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11239   return jresult;
11240 }
11241
11242
11243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11244   void * jresult ;
11245   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11246   Dali::Quaternion *arg2 = 0 ;
11247   Dali::Quaternion result;
11248
11249   arg1 = (Dali::Quaternion *)jarg1;
11250   arg2 = (Dali::Quaternion *)jarg2;
11251   if (!arg2) {
11252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11253     return 0;
11254   }
11255   {
11256     try {
11257       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11258     } catch (std::out_of_range& e) {
11259       {
11260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11261       };
11262     } catch (std::exception& e) {
11263       {
11264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11265       };
11266     } catch (Dali::DaliException e) {
11267       {
11268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11269       };
11270     } catch (...) {
11271       {
11272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11273       };
11274     }
11275   }
11276
11277   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11278   return jresult;
11279 }
11280
11281
11282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11283   void * jresult ;
11284   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11285   float arg2 ;
11286   Dali::Quaternion result;
11287
11288   arg1 = (Dali::Quaternion *)jarg1;
11289   arg2 = (float)jarg2;
11290   {
11291     try {
11292       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11293     } catch (std::out_of_range& e) {
11294       {
11295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11296       };
11297     } catch (std::exception& e) {
11298       {
11299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11300       };
11301     } catch (Dali::DaliException e) {
11302       {
11303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11304       };
11305     } catch (...) {
11306       {
11307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11308       };
11309     }
11310   }
11311
11312   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11313   return jresult;
11314 }
11315
11316
11317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11318   void * jresult ;
11319   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11320   float arg2 ;
11321   Dali::Quaternion result;
11322
11323   arg1 = (Dali::Quaternion *)jarg1;
11324   arg2 = (float)jarg2;
11325   {
11326     try {
11327       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11328     } catch (std::out_of_range& e) {
11329       {
11330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11331       };
11332     } catch (std::exception& e) {
11333       {
11334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11335       };
11336     } catch (Dali::DaliException e) {
11337       {
11338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11339       };
11340     } catch (...) {
11341       {
11342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11343       };
11344     }
11345   }
11346
11347   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11348   return jresult;
11349 }
11350
11351
11352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11353   void * jresult ;
11354   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11355   Dali::Quaternion result;
11356
11357   arg1 = (Dali::Quaternion *)jarg1;
11358   {
11359     try {
11360       result = ((Dali::Quaternion const *)arg1)->operator -();
11361     } catch (std::out_of_range& e) {
11362       {
11363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11364       };
11365     } catch (std::exception& e) {
11366       {
11367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11368       };
11369     } catch (Dali::DaliException e) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11372       };
11373     } catch (...) {
11374       {
11375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11376       };
11377     }
11378   }
11379
11380   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11381   return jresult;
11382 }
11383
11384
11385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11386   void * jresult ;
11387   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11388   Dali::Quaternion *arg2 = 0 ;
11389   Dali::Quaternion *result = 0 ;
11390
11391   arg1 = (Dali::Quaternion *)jarg1;
11392   arg2 = (Dali::Quaternion *)jarg2;
11393   if (!arg2) {
11394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11395     return 0;
11396   }
11397   {
11398     try {
11399       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11400     } catch (std::out_of_range& e) {
11401       {
11402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11403       };
11404     } catch (std::exception& e) {
11405       {
11406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11407       };
11408     } catch (Dali::DaliException e) {
11409       {
11410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11411       };
11412     } catch (...) {
11413       {
11414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11415       };
11416     }
11417   }
11418
11419   jresult = (void *)result;
11420   return jresult;
11421 }
11422
11423
11424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11425   void * jresult ;
11426   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11427   Dali::Quaternion *arg2 = 0 ;
11428   Dali::Quaternion *result = 0 ;
11429
11430   arg1 = (Dali::Quaternion *)jarg1;
11431   arg2 = (Dali::Quaternion *)jarg2;
11432   if (!arg2) {
11433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11434     return 0;
11435   }
11436   {
11437     try {
11438       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11439     } catch (std::out_of_range& e) {
11440       {
11441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11442       };
11443     } catch (std::exception& e) {
11444       {
11445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11446       };
11447     } catch (Dali::DaliException e) {
11448       {
11449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11450       };
11451     } catch (...) {
11452       {
11453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11454       };
11455     }
11456   }
11457
11458   jresult = (void *)result;
11459   return jresult;
11460 }
11461
11462
11463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11464   void * jresult ;
11465   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11466   Dali::Quaternion *arg2 = 0 ;
11467   Dali::Quaternion *result = 0 ;
11468
11469   arg1 = (Dali::Quaternion *)jarg1;
11470   arg2 = (Dali::Quaternion *)jarg2;
11471   if (!arg2) {
11472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11473     return 0;
11474   }
11475   {
11476     try {
11477       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11478     } catch (std::out_of_range& e) {
11479       {
11480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11481       };
11482     } catch (std::exception& e) {
11483       {
11484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11485       };
11486     } catch (Dali::DaliException e) {
11487       {
11488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11489       };
11490     } catch (...) {
11491       {
11492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11493       };
11494     }
11495   }
11496
11497   jresult = (void *)result;
11498   return jresult;
11499 }
11500
11501
11502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11503   void * jresult ;
11504   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11505   float arg2 ;
11506   Dali::Quaternion *result = 0 ;
11507
11508   arg1 = (Dali::Quaternion *)jarg1;
11509   arg2 = (float)jarg2;
11510   {
11511     try {
11512       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11513     } catch (std::out_of_range& e) {
11514       {
11515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11516       };
11517     } catch (std::exception& e) {
11518       {
11519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11520       };
11521     } catch (Dali::DaliException e) {
11522       {
11523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11524       };
11525     } catch (...) {
11526       {
11527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11528       };
11529     }
11530   }
11531
11532   jresult = (void *)result;
11533   return jresult;
11534 }
11535
11536
11537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11538   void * jresult ;
11539   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11540   float arg2 ;
11541   Dali::Quaternion *result = 0 ;
11542
11543   arg1 = (Dali::Quaternion *)jarg1;
11544   arg2 = (float)jarg2;
11545   {
11546     try {
11547       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11548     } catch (std::out_of_range& e) {
11549       {
11550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11551       };
11552     } catch (std::exception& e) {
11553       {
11554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11555       };
11556     } catch (Dali::DaliException e) {
11557       {
11558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11559       };
11560     } catch (...) {
11561       {
11562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11563       };
11564     }
11565   }
11566
11567   jresult = (void *)result;
11568   return jresult;
11569 }
11570
11571
11572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11573   unsigned int jresult ;
11574   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11575   Dali::Quaternion *arg2 = 0 ;
11576   bool result;
11577
11578   arg1 = (Dali::Quaternion *)jarg1;
11579   arg2 = (Dali::Quaternion *)jarg2;
11580   if (!arg2) {
11581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11582     return 0;
11583   }
11584   {
11585     try {
11586       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11587     } catch (std::out_of_range& e) {
11588       {
11589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11590       };
11591     } catch (std::exception& e) {
11592       {
11593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11594       };
11595     } catch (Dali::DaliException e) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11598       };
11599     } catch (...) {
11600       {
11601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11602       };
11603     }
11604   }
11605
11606   jresult = result;
11607   return jresult;
11608 }
11609
11610
11611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11612   unsigned int jresult ;
11613   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11614   Dali::Quaternion *arg2 = 0 ;
11615   bool result;
11616
11617   arg1 = (Dali::Quaternion *)jarg1;
11618   arg2 = (Dali::Quaternion *)jarg2;
11619   if (!arg2) {
11620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11621     return 0;
11622   }
11623   {
11624     try {
11625       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11626     } catch (std::out_of_range& e) {
11627       {
11628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11629       };
11630     } catch (std::exception& e) {
11631       {
11632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11633       };
11634     } catch (Dali::DaliException e) {
11635       {
11636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11637       };
11638     } catch (...) {
11639       {
11640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11641       };
11642     }
11643   }
11644
11645   jresult = result;
11646   return jresult;
11647 }
11648
11649
11650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11651   float jresult ;
11652   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11653   float result;
11654
11655   arg1 = (Dali::Quaternion *)jarg1;
11656   {
11657     try {
11658       result = (float)((Dali::Quaternion const *)arg1)->Length();
11659     } catch (std::out_of_range& e) {
11660       {
11661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (std::exception& e) {
11664       {
11665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11666       };
11667     } catch (Dali::DaliException e) {
11668       {
11669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11670       };
11671     } catch (...) {
11672       {
11673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11674       };
11675     }
11676   }
11677
11678   jresult = result;
11679   return jresult;
11680 }
11681
11682
11683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11684   float jresult ;
11685   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11686   float result;
11687
11688   arg1 = (Dali::Quaternion *)jarg1;
11689   {
11690     try {
11691       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11692     } catch (std::out_of_range& e) {
11693       {
11694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11695       };
11696     } catch (std::exception& e) {
11697       {
11698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11699       };
11700     } catch (Dali::DaliException e) {
11701       {
11702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11703       };
11704     } catch (...) {
11705       {
11706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11707       };
11708     }
11709   }
11710
11711   jresult = result;
11712   return jresult;
11713 }
11714
11715
11716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11717   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11718
11719   arg1 = (Dali::Quaternion *)jarg1;
11720   {
11721     try {
11722       (arg1)->Normalize();
11723     } catch (std::out_of_range& e) {
11724       {
11725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (std::exception& e) {
11728       {
11729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11730       };
11731     } catch (Dali::DaliException e) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11734       };
11735     } catch (...) {
11736       {
11737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11738       };
11739     }
11740   }
11741
11742 }
11743
11744
11745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11746   void * jresult ;
11747   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11748   Dali::Quaternion result;
11749
11750   arg1 = (Dali::Quaternion *)jarg1;
11751   {
11752     try {
11753       result = ((Dali::Quaternion const *)arg1)->Normalized();
11754     } catch (std::out_of_range& e) {
11755       {
11756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11757       };
11758     } catch (std::exception& e) {
11759       {
11760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11761       };
11762     } catch (Dali::DaliException e) {
11763       {
11764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11765       };
11766     } catch (...) {
11767       {
11768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11769       };
11770     }
11771   }
11772
11773   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11774   return jresult;
11775 }
11776
11777
11778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11779   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11780
11781   arg1 = (Dali::Quaternion *)jarg1;
11782   {
11783     try {
11784       (arg1)->Conjugate();
11785     } catch (std::out_of_range& e) {
11786       {
11787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11788       };
11789     } catch (std::exception& e) {
11790       {
11791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11792       };
11793     } catch (Dali::DaliException e) {
11794       {
11795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11796       };
11797     } catch (...) {
11798       {
11799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11800       };
11801     }
11802   }
11803
11804 }
11805
11806
11807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11808   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11809
11810   arg1 = (Dali::Quaternion *)jarg1;
11811   {
11812     try {
11813       (arg1)->Invert();
11814     } catch (std::out_of_range& e) {
11815       {
11816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11817       };
11818     } catch (std::exception& e) {
11819       {
11820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11821       };
11822     } catch (Dali::DaliException e) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11825       };
11826     } catch (...) {
11827       {
11828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11829       };
11830     }
11831   }
11832
11833 }
11834
11835
11836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11837   void * jresult ;
11838   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11839   Dali::Quaternion result;
11840
11841   arg1 = (Dali::Quaternion *)jarg1;
11842   {
11843     try {
11844       result = ((Dali::Quaternion const *)arg1)->Log();
11845     } catch (std::out_of_range& e) {
11846       {
11847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11848       };
11849     } catch (std::exception& e) {
11850       {
11851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11852       };
11853     } catch (Dali::DaliException e) {
11854       {
11855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11856       };
11857     } catch (...) {
11858       {
11859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11860       };
11861     }
11862   }
11863
11864   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11865   return jresult;
11866 }
11867
11868
11869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11870   void * jresult ;
11871   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11872   Dali::Quaternion result;
11873
11874   arg1 = (Dali::Quaternion *)jarg1;
11875   {
11876     try {
11877       result = ((Dali::Quaternion const *)arg1)->Exp();
11878     } catch (std::out_of_range& e) {
11879       {
11880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11881       };
11882     } catch (std::exception& e) {
11883       {
11884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11885       };
11886     } catch (Dali::DaliException e) {
11887       {
11888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11889       };
11890     } catch (...) {
11891       {
11892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11893       };
11894     }
11895   }
11896
11897   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11898   return jresult;
11899 }
11900
11901
11902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11903   float jresult ;
11904   Dali::Quaternion *arg1 = 0 ;
11905   Dali::Quaternion *arg2 = 0 ;
11906   float result;
11907
11908   arg1 = (Dali::Quaternion *)jarg1;
11909   if (!arg1) {
11910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11911     return 0;
11912   }
11913   arg2 = (Dali::Quaternion *)jarg2;
11914   if (!arg2) {
11915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11916     return 0;
11917   }
11918   {
11919     try {
11920       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (Dali::DaliException e) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11932       };
11933     } catch (...) {
11934       {
11935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11936       };
11937     }
11938   }
11939
11940   jresult = result;
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11946   void * jresult ;
11947   Dali::Quaternion *arg1 = 0 ;
11948   Dali::Quaternion *arg2 = 0 ;
11949   float arg3 ;
11950   Dali::Quaternion result;
11951
11952   arg1 = (Dali::Quaternion *)jarg1;
11953   if (!arg1) {
11954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11955     return 0;
11956   }
11957   arg2 = (Dali::Quaternion *)jarg2;
11958   if (!arg2) {
11959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11960     return 0;
11961   }
11962   arg3 = (float)jarg3;
11963   {
11964     try {
11965       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11966     } catch (std::out_of_range& e) {
11967       {
11968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (std::exception& e) {
11971       {
11972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11973       };
11974     } catch (Dali::DaliException e) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11977       };
11978     } catch (...) {
11979       {
11980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11981       };
11982     }
11983   }
11984
11985   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11991   void * jresult ;
11992   Dali::Quaternion *arg1 = 0 ;
11993   Dali::Quaternion *arg2 = 0 ;
11994   float arg3 ;
11995   Dali::Quaternion result;
11996
11997   arg1 = (Dali::Quaternion *)jarg1;
11998   if (!arg1) {
11999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12000     return 0;
12001   }
12002   arg2 = (Dali::Quaternion *)jarg2;
12003   if (!arg2) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12005     return 0;
12006   }
12007   arg3 = (float)jarg3;
12008   {
12009     try {
12010       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12011     } catch (std::out_of_range& e) {
12012       {
12013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (std::exception& e) {
12016       {
12017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12018       };
12019     } catch (Dali::DaliException e) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12022       };
12023     } catch (...) {
12024       {
12025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12026       };
12027     }
12028   }
12029
12030   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12031   return jresult;
12032 }
12033
12034
12035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12036   void * jresult ;
12037   Dali::Quaternion *arg1 = 0 ;
12038   Dali::Quaternion *arg2 = 0 ;
12039   float arg3 ;
12040   Dali::Quaternion result;
12041
12042   arg1 = (Dali::Quaternion *)jarg1;
12043   if (!arg1) {
12044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12045     return 0;
12046   }
12047   arg2 = (Dali::Quaternion *)jarg2;
12048   if (!arg2) {
12049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12050     return 0;
12051   }
12052   arg3 = (float)jarg3;
12053   {
12054     try {
12055       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12056     } catch (std::out_of_range& e) {
12057       {
12058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12059       };
12060     } catch (std::exception& e) {
12061       {
12062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12063       };
12064     } catch (Dali::DaliException e) {
12065       {
12066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12067       };
12068     } catch (...) {
12069       {
12070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12071       };
12072     }
12073   }
12074
12075   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12076   return jresult;
12077 }
12078
12079
12080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12081   void * jresult ;
12082   Dali::Quaternion *arg1 = 0 ;
12083   Dali::Quaternion *arg2 = 0 ;
12084   Dali::Quaternion *arg3 = 0 ;
12085   Dali::Quaternion *arg4 = 0 ;
12086   float arg5 ;
12087   Dali::Quaternion result;
12088
12089   arg1 = (Dali::Quaternion *)jarg1;
12090   if (!arg1) {
12091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12092     return 0;
12093   }
12094   arg2 = (Dali::Quaternion *)jarg2;
12095   if (!arg2) {
12096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12097     return 0;
12098   }
12099   arg3 = (Dali::Quaternion *)jarg3;
12100   if (!arg3) {
12101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12102     return 0;
12103   }
12104   arg4 = (Dali::Quaternion *)jarg4;
12105   if (!arg4) {
12106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12107     return 0;
12108   }
12109   arg5 = (float)jarg5;
12110   {
12111     try {
12112       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12113     } catch (std::out_of_range& e) {
12114       {
12115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (std::exception& e) {
12118       {
12119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12120       };
12121     } catch (Dali::DaliException e) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12124       };
12125     } catch (...) {
12126       {
12127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12128       };
12129     }
12130   }
12131
12132   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12133   return jresult;
12134 }
12135
12136
12137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12138   float jresult ;
12139   Dali::Quaternion *arg1 = 0 ;
12140   Dali::Quaternion *arg2 = 0 ;
12141   float result;
12142
12143   arg1 = (Dali::Quaternion *)jarg1;
12144   if (!arg1) {
12145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12146     return 0;
12147   }
12148   arg2 = (Dali::Quaternion *)jarg2;
12149   if (!arg2) {
12150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12151     return 0;
12152   }
12153   {
12154     try {
12155       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12156     } catch (std::out_of_range& e) {
12157       {
12158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (std::exception& e) {
12161       {
12162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12163       };
12164     } catch (Dali::DaliException e) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12167       };
12168     } catch (...) {
12169       {
12170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12171       };
12172     }
12173   }
12174
12175   jresult = result;
12176   return jresult;
12177 }
12178
12179
12180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12181   void * jresult ;
12182   Dali::Matrix *result = 0 ;
12183
12184   {
12185     try {
12186       result = (Dali::Matrix *)new Dali::Matrix();
12187     } catch (std::out_of_range& e) {
12188       {
12189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12190       };
12191     } catch (std::exception& e) {
12192       {
12193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12194       };
12195     } catch (Dali::DaliException e) {
12196       {
12197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12198       };
12199     } catch (...) {
12200       {
12201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12202       };
12203     }
12204   }
12205
12206   jresult = (void *)result;
12207   return jresult;
12208 }
12209
12210
12211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12212   void * jresult ;
12213   bool arg1 ;
12214   Dali::Matrix *result = 0 ;
12215
12216   arg1 = jarg1 ? true : false;
12217   {
12218     try {
12219       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12220     } catch (std::out_of_range& e) {
12221       {
12222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (std::exception& e) {
12225       {
12226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12227       };
12228     } catch (Dali::DaliException e) {
12229       {
12230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12231       };
12232     } catch (...) {
12233       {
12234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12235       };
12236     }
12237   }
12238
12239   jresult = (void *)result;
12240   return jresult;
12241 }
12242
12243
12244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12245   void * jresult ;
12246   float *arg1 = (float *) 0 ;
12247   Dali::Matrix *result = 0 ;
12248
12249   arg1 = jarg1;
12250   {
12251     try {
12252       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12253     } catch (std::out_of_range& e) {
12254       {
12255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12256       };
12257     } catch (std::exception& e) {
12258       {
12259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12260       };
12261     } catch (Dali::DaliException e) {
12262       {
12263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12264       };
12265     } catch (...) {
12266       {
12267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12268       };
12269     }
12270   }
12271
12272   jresult = (void *)result;
12273
12274
12275   return jresult;
12276 }
12277
12278
12279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12280   void * jresult ;
12281   Dali::Quaternion *arg1 = 0 ;
12282   Dali::Matrix *result = 0 ;
12283
12284   arg1 = (Dali::Quaternion *)jarg1;
12285   if (!arg1) {
12286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12287     return 0;
12288   }
12289   {
12290     try {
12291       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12292     } catch (std::out_of_range& e) {
12293       {
12294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (std::exception& e) {
12297       {
12298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12299       };
12300     } catch (Dali::DaliException e) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12303       };
12304     } catch (...) {
12305       {
12306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12307       };
12308     }
12309   }
12310
12311   jresult = (void *)result;
12312   return jresult;
12313 }
12314
12315
12316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12317   void * jresult ;
12318   Dali::Matrix *arg1 = 0 ;
12319   Dali::Matrix *result = 0 ;
12320
12321   arg1 = (Dali::Matrix *)jarg1;
12322   if (!arg1) {
12323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12324     return 0;
12325   }
12326   {
12327     try {
12328       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12329     } catch (std::out_of_range& e) {
12330       {
12331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (std::exception& e) {
12334       {
12335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12336       };
12337     } catch (Dali::DaliException e) {
12338       {
12339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12340       };
12341     } catch (...) {
12342       {
12343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12344       };
12345     }
12346   }
12347
12348   jresult = (void *)result;
12349   return jresult;
12350 }
12351
12352
12353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12354   void * jresult ;
12355   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12356   Dali::Matrix *arg2 = 0 ;
12357   Dali::Matrix *result = 0 ;
12358
12359   arg1 = (Dali::Matrix *)jarg1;
12360   arg2 = (Dali::Matrix *)jarg2;
12361   if (!arg2) {
12362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12363     return 0;
12364   }
12365   {
12366     try {
12367       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12368     } catch (std::out_of_range& e) {
12369       {
12370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12371       };
12372     } catch (std::exception& e) {
12373       {
12374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12375       };
12376     } catch (Dali::DaliException e) {
12377       {
12378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12379       };
12380     } catch (...) {
12381       {
12382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12383       };
12384     }
12385   }
12386
12387   jresult = (void *)result;
12388   return jresult;
12389 }
12390
12391
12392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12393   void * jresult ;
12394   Dali::Matrix *result = 0 ;
12395
12396   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12397   jresult = (void *)result;
12398   return jresult;
12399 }
12400
12401
12402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12403   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12404
12405   arg1 = (Dali::Matrix *)jarg1;
12406   {
12407     try {
12408       (arg1)->SetIdentity();
12409     } catch (std::out_of_range& e) {
12410       {
12411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12412       };
12413     } catch (std::exception& e) {
12414       {
12415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12416       };
12417     } catch (Dali::DaliException e) {
12418       {
12419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12420       };
12421     } catch (...) {
12422       {
12423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12424       };
12425     }
12426   }
12427
12428 }
12429
12430
12431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12432   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12433   Dali::Vector3 *arg2 = 0 ;
12434
12435   arg1 = (Dali::Matrix *)jarg1;
12436   arg2 = (Dali::Vector3 *)jarg2;
12437   if (!arg2) {
12438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12439     return ;
12440   }
12441   {
12442     try {
12443       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12444     } catch (std::out_of_range& e) {
12445       {
12446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12447       };
12448     } catch (std::exception& e) {
12449       {
12450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12451       };
12452     } catch (Dali::DaliException e) {
12453       {
12454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12455       };
12456     } catch (...) {
12457       {
12458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12459       };
12460     }
12461   }
12462
12463 }
12464
12465
12466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12467   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12468   Dali::Matrix *arg2 = 0 ;
12469
12470   arg1 = (Dali::Matrix *)jarg1;
12471   arg2 = (Dali::Matrix *)jarg2;
12472   if (!arg2) {
12473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12474     return ;
12475   }
12476   {
12477     try {
12478       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12479     } catch (std::out_of_range& e) {
12480       {
12481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12482       };
12483     } catch (std::exception& e) {
12484       {
12485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12486       };
12487     } catch (Dali::DaliException e) {
12488       {
12489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12490       };
12491     } catch (...) {
12492       {
12493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12494       };
12495     }
12496   }
12497
12498 }
12499
12500
12501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12502   unsigned int jresult ;
12503   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12504   bool result;
12505
12506   arg1 = (Dali::Matrix *)jarg1;
12507   {
12508     try {
12509       result = (bool)(arg1)->Invert();
12510     } catch (std::out_of_range& e) {
12511       {
12512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (std::exception& e) {
12515       {
12516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12517       };
12518     } catch (Dali::DaliException e) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12521       };
12522     } catch (...) {
12523       {
12524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12525       };
12526     }
12527   }
12528
12529   jresult = result;
12530   return jresult;
12531 }
12532
12533
12534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12535   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12536
12537   arg1 = (Dali::Matrix *)jarg1;
12538   {
12539     try {
12540       (arg1)->Transpose();
12541     } catch (std::out_of_range& e) {
12542       {
12543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12544       };
12545     } catch (std::exception& e) {
12546       {
12547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12548       };
12549     } catch (Dali::DaliException e) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12552       };
12553     } catch (...) {
12554       {
12555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12556       };
12557     }
12558   }
12559
12560 }
12561
12562
12563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12564   void * jresult ;
12565   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12566   Dali::Vector3 result;
12567
12568   arg1 = (Dali::Matrix *)jarg1;
12569   {
12570     try {
12571       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12572     } catch (std::out_of_range& e) {
12573       {
12574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (std::exception& e) {
12577       {
12578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12579       };
12580     } catch (Dali::DaliException e) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12583       };
12584     } catch (...) {
12585       {
12586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12587       };
12588     }
12589   }
12590
12591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12592   return jresult;
12593 }
12594
12595
12596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12597   void * jresult ;
12598   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12599   Dali::Vector3 result;
12600
12601   arg1 = (Dali::Matrix *)jarg1;
12602   {
12603     try {
12604       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12605     } catch (std::out_of_range& e) {
12606       {
12607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12608       };
12609     } catch (std::exception& e) {
12610       {
12611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12612       };
12613     } catch (Dali::DaliException e) {
12614       {
12615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12616       };
12617     } catch (...) {
12618       {
12619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12620       };
12621     }
12622   }
12623
12624   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12625   return jresult;
12626 }
12627
12628
12629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12630   void * jresult ;
12631   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12632   Dali::Vector3 result;
12633
12634   arg1 = (Dali::Matrix *)jarg1;
12635   {
12636     try {
12637       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12638     } catch (std::out_of_range& e) {
12639       {
12640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12641       };
12642     } catch (std::exception& e) {
12643       {
12644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12645       };
12646     } catch (Dali::DaliException e) {
12647       {
12648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12649       };
12650     } catch (...) {
12651       {
12652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12653       };
12654     }
12655   }
12656
12657   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12658   return jresult;
12659 }
12660
12661
12662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12663   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12664   Dali::Vector3 *arg2 = 0 ;
12665
12666   arg1 = (Dali::Matrix *)jarg1;
12667   arg2 = (Dali::Vector3 *)jarg2;
12668   if (!arg2) {
12669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12670     return ;
12671   }
12672   {
12673     try {
12674       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12675     } catch (std::out_of_range& e) {
12676       {
12677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12678       };
12679     } catch (std::exception& e) {
12680       {
12681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12682       };
12683     } catch (Dali::DaliException e) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12686       };
12687     } catch (...) {
12688       {
12689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12690       };
12691     }
12692   }
12693
12694 }
12695
12696
12697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12698   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12699   Dali::Vector3 *arg2 = 0 ;
12700
12701   arg1 = (Dali::Matrix *)jarg1;
12702   arg2 = (Dali::Vector3 *)jarg2;
12703   if (!arg2) {
12704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12705     return ;
12706   }
12707   {
12708     try {
12709       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12710     } catch (std::out_of_range& e) {
12711       {
12712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12713       };
12714     } catch (std::exception& e) {
12715       {
12716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12717       };
12718     } catch (Dali::DaliException e) {
12719       {
12720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12721       };
12722     } catch (...) {
12723       {
12724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12725       };
12726     }
12727   }
12728
12729 }
12730
12731
12732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12733   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12734   Dali::Vector3 *arg2 = 0 ;
12735
12736   arg1 = (Dali::Matrix *)jarg1;
12737   arg2 = (Dali::Vector3 *)jarg2;
12738   if (!arg2) {
12739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12740     return ;
12741   }
12742   {
12743     try {
12744       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12745     } catch (std::out_of_range& e) {
12746       {
12747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12748       };
12749     } catch (std::exception& e) {
12750       {
12751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12752       };
12753     } catch (Dali::DaliException e) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12756       };
12757     } catch (...) {
12758       {
12759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12760       };
12761     }
12762   }
12763
12764 }
12765
12766
12767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12768   void * jresult ;
12769   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12770   Dali::Vector4 *result = 0 ;
12771
12772   arg1 = (Dali::Matrix *)jarg1;
12773   {
12774     try {
12775       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12776     } catch (std::out_of_range& e) {
12777       {
12778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12779       };
12780     } catch (std::exception& e) {
12781       {
12782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12783       };
12784     } catch (Dali::DaliException e) {
12785       {
12786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12787       };
12788     } catch (...) {
12789       {
12790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12791       };
12792     }
12793   }
12794
12795   jresult = (void *)result;
12796   return jresult;
12797 }
12798
12799
12800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12801   void * jresult ;
12802   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12803   Dali::Vector3 *result = 0 ;
12804
12805   arg1 = (Dali::Matrix *)jarg1;
12806   {
12807     try {
12808       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12809     } catch (std::out_of_range& e) {
12810       {
12811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12812       };
12813     } catch (std::exception& e) {
12814       {
12815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12816       };
12817     } catch (Dali::DaliException e) {
12818       {
12819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12820       };
12821     } catch (...) {
12822       {
12823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12824       };
12825     }
12826   }
12827
12828   jresult = (void *)result;
12829   return jresult;
12830 }
12831
12832
12833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12834   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12835   Dali::Vector4 *arg2 = 0 ;
12836
12837   arg1 = (Dali::Matrix *)jarg1;
12838   arg2 = (Dali::Vector4 *)jarg2;
12839   if (!arg2) {
12840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12841     return ;
12842   }
12843   {
12844     try {
12845       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12846     } catch (std::out_of_range& e) {
12847       {
12848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12849       };
12850     } catch (std::exception& e) {
12851       {
12852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12853       };
12854     } catch (Dali::DaliException e) {
12855       {
12856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12857       };
12858     } catch (...) {
12859       {
12860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12861       };
12862     }
12863   }
12864
12865 }
12866
12867
12868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12869   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12870   Dali::Vector3 *arg2 = 0 ;
12871
12872   arg1 = (Dali::Matrix *)jarg1;
12873   arg2 = (Dali::Vector3 *)jarg2;
12874   if (!arg2) {
12875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12876     return ;
12877   }
12878   {
12879     try {
12880       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12881     } catch (std::out_of_range& e) {
12882       {
12883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12884       };
12885     } catch (std::exception& e) {
12886       {
12887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12888       };
12889     } catch (Dali::DaliException e) {
12890       {
12891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12892       };
12893     } catch (...) {
12894       {
12895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12896       };
12897     }
12898   }
12899
12900 }
12901
12902
12903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12904   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12905
12906   arg1 = (Dali::Matrix *)jarg1;
12907   {
12908     try {
12909       (arg1)->OrthoNormalize();
12910     } catch (std::out_of_range& e) {
12911       {
12912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12913       };
12914     } catch (std::exception& e) {
12915       {
12916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12917       };
12918     } catch (Dali::DaliException e) {
12919       {
12920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12921       };
12922     } catch (...) {
12923       {
12924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12925       };
12926     }
12927   }
12928
12929 }
12930
12931
12932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12933   void * jresult ;
12934   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12935   float *result = 0 ;
12936
12937   arg1 = (Dali::Matrix *)jarg1;
12938   {
12939     try {
12940       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12941     } catch (std::out_of_range& e) {
12942       {
12943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12944       };
12945     } catch (std::exception& e) {
12946       {
12947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12948       };
12949     } catch (Dali::DaliException e) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12952       };
12953     } catch (...) {
12954       {
12955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12956       };
12957     }
12958   }
12959
12960   jresult = (void *)result;
12961   return jresult;
12962 }
12963
12964
12965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12966   Dali::Matrix *arg1 = 0 ;
12967   Dali::Matrix *arg2 = 0 ;
12968   Dali::Matrix *arg3 = 0 ;
12969
12970   arg1 = (Dali::Matrix *)jarg1;
12971   if (!arg1) {
12972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12973     return ;
12974   }
12975   arg2 = (Dali::Matrix *)jarg2;
12976   if (!arg2) {
12977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12978     return ;
12979   }
12980   arg3 = (Dali::Matrix *)jarg3;
12981   if (!arg3) {
12982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12983     return ;
12984   }
12985   {
12986     try {
12987       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12988     } catch (std::out_of_range& e) {
12989       {
12990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (std::exception& e) {
12993       {
12994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12995       };
12996     } catch (Dali::DaliException e) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12999       };
13000     } catch (...) {
13001       {
13002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13003       };
13004     }
13005   }
13006
13007 }
13008
13009
13010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13011   Dali::Matrix *arg1 = 0 ;
13012   Dali::Matrix *arg2 = 0 ;
13013   Dali::Quaternion *arg3 = 0 ;
13014
13015   arg1 = (Dali::Matrix *)jarg1;
13016   if (!arg1) {
13017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13018     return ;
13019   }
13020   arg2 = (Dali::Matrix *)jarg2;
13021   if (!arg2) {
13022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13023     return ;
13024   }
13025   arg3 = (Dali::Quaternion *)jarg3;
13026   if (!arg3) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13028     return ;
13029   }
13030   {
13031     try {
13032       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13033     } catch (std::out_of_range& e) {
13034       {
13035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13036       };
13037     } catch (std::exception& e) {
13038       {
13039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13040       };
13041     } catch (Dali::DaliException e) {
13042       {
13043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13044       };
13045     } catch (...) {
13046       {
13047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13048       };
13049     }
13050   }
13051
13052 }
13053
13054
13055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13056   void * jresult ;
13057   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13058   Dali::Vector4 *arg2 = 0 ;
13059   Dali::Vector4 result;
13060
13061   arg1 = (Dali::Matrix *)jarg1;
13062   arg2 = (Dali::Vector4 *)jarg2;
13063   if (!arg2) {
13064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13065     return 0;
13066   }
13067   {
13068     try {
13069       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13070     } catch (std::out_of_range& e) {
13071       {
13072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (std::exception& e) {
13075       {
13076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13077       };
13078     } catch (Dali::DaliException e) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13081       };
13082     } catch (...) {
13083       {
13084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13085       };
13086     }
13087   }
13088
13089   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13090   return jresult;
13091 }
13092
13093
13094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13095   unsigned int jresult ;
13096   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13097   Dali::Matrix *arg2 = 0 ;
13098   bool result;
13099
13100   arg1 = (Dali::Matrix *)jarg1;
13101   arg2 = (Dali::Matrix *)jarg2;
13102   if (!arg2) {
13103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13104     return 0;
13105   }
13106   {
13107     try {
13108       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13109     } catch (std::out_of_range& e) {
13110       {
13111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (std::exception& e) {
13114       {
13115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13116       };
13117     } catch (Dali::DaliException e) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13120       };
13121     } catch (...) {
13122       {
13123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13124       };
13125     }
13126   }
13127
13128   jresult = result;
13129   return jresult;
13130 }
13131
13132
13133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13134   unsigned int jresult ;
13135   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13136   Dali::Matrix *arg2 = 0 ;
13137   bool result;
13138
13139   arg1 = (Dali::Matrix *)jarg1;
13140   arg2 = (Dali::Matrix *)jarg2;
13141   if (!arg2) {
13142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13143     return 0;
13144   }
13145   {
13146     try {
13147       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13148     } catch (std::out_of_range& e) {
13149       {
13150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13151       };
13152     } catch (std::exception& e) {
13153       {
13154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13155       };
13156     } catch (Dali::DaliException e) {
13157       {
13158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13159       };
13160     } catch (...) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13163       };
13164     }
13165   }
13166
13167   jresult = result;
13168   return jresult;
13169 }
13170
13171
13172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13173   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13174   Dali::Vector3 *arg2 = 0 ;
13175   Dali::Quaternion *arg3 = 0 ;
13176   Dali::Vector3 *arg4 = 0 ;
13177
13178   arg1 = (Dali::Matrix *)jarg1;
13179   arg2 = (Dali::Vector3 *)jarg2;
13180   if (!arg2) {
13181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13182     return ;
13183   }
13184   arg3 = (Dali::Quaternion *)jarg3;
13185   if (!arg3) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13187     return ;
13188   }
13189   arg4 = (Dali::Vector3 *)jarg4;
13190   if (!arg4) {
13191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13192     return ;
13193   }
13194   {
13195     try {
13196       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13197     } catch (std::out_of_range& e) {
13198       {
13199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13200       };
13201     } catch (std::exception& e) {
13202       {
13203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13204       };
13205     } catch (Dali::DaliException e) {
13206       {
13207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13208       };
13209     } catch (...) {
13210       {
13211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13212       };
13213     }
13214   }
13215
13216 }
13217
13218
13219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13220   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13221   Dali::Vector3 *arg2 = 0 ;
13222   Dali::Quaternion *arg3 = 0 ;
13223   Dali::Vector3 *arg4 = 0 ;
13224
13225   arg1 = (Dali::Matrix *)jarg1;
13226   arg2 = (Dali::Vector3 *)jarg2;
13227   if (!arg2) {
13228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13229     return ;
13230   }
13231   arg3 = (Dali::Quaternion *)jarg3;
13232   if (!arg3) {
13233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13234     return ;
13235   }
13236   arg4 = (Dali::Vector3 *)jarg4;
13237   if (!arg4) {
13238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13239     return ;
13240   }
13241   {
13242     try {
13243       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13244     } catch (std::out_of_range& e) {
13245       {
13246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13247       };
13248     } catch (std::exception& e) {
13249       {
13250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13251       };
13252     } catch (Dali::DaliException e) {
13253       {
13254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13255       };
13256     } catch (...) {
13257       {
13258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13259       };
13260     }
13261   }
13262
13263 }
13264
13265
13266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13267   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13268   Dali::Vector3 *arg2 = 0 ;
13269   Dali::Vector3 *arg3 = 0 ;
13270   Dali::Vector3 *arg4 = 0 ;
13271   Dali::Vector3 *arg5 = 0 ;
13272
13273   arg1 = (Dali::Matrix *)jarg1;
13274   arg2 = (Dali::Vector3 *)jarg2;
13275   if (!arg2) {
13276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13277     return ;
13278   }
13279   arg3 = (Dali::Vector3 *)jarg3;
13280   if (!arg3) {
13281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13282     return ;
13283   }
13284   arg4 = (Dali::Vector3 *)jarg4;
13285   if (!arg4) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13287     return ;
13288   }
13289   arg5 = (Dali::Vector3 *)jarg5;
13290   if (!arg5) {
13291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13292     return ;
13293   }
13294   {
13295     try {
13296       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13297     } catch (std::out_of_range& e) {
13298       {
13299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13300       };
13301     } catch (std::exception& e) {
13302       {
13303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13304       };
13305     } catch (Dali::DaliException e) {
13306       {
13307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13308       };
13309     } catch (...) {
13310       {
13311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13312       };
13313     }
13314   }
13315
13316 }
13317
13318
13319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13320   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13321   Dali::Vector3 *arg2 = 0 ;
13322   Dali::Quaternion *arg3 = 0 ;
13323   Dali::Vector3 *arg4 = 0 ;
13324
13325   arg1 = (Dali::Matrix *)jarg1;
13326   arg2 = (Dali::Vector3 *)jarg2;
13327   if (!arg2) {
13328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13329     return ;
13330   }
13331   arg3 = (Dali::Quaternion *)jarg3;
13332   if (!arg3) {
13333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13334     return ;
13335   }
13336   arg4 = (Dali::Vector3 *)jarg4;
13337   if (!arg4) {
13338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13339     return ;
13340   }
13341   {
13342     try {
13343       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13344     } catch (std::out_of_range& e) {
13345       {
13346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13347       };
13348     } catch (std::exception& e) {
13349       {
13350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13351       };
13352     } catch (Dali::DaliException e) {
13353       {
13354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13355       };
13356     } catch (...) {
13357       {
13358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13359       };
13360     }
13361   }
13362
13363 }
13364
13365
13366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13367   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13368
13369   arg1 = (Dali::Matrix *)jarg1;
13370   {
13371     try {
13372       delete arg1;
13373     } catch (std::out_of_range& e) {
13374       {
13375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13376       };
13377     } catch (std::exception& e) {
13378       {
13379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13380       };
13381     } catch (Dali::DaliException e) {
13382       {
13383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13384       };
13385     } catch (...) {
13386       {
13387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13388       };
13389     }
13390   }
13391
13392 }
13393
13394
13395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13396   void * jresult ;
13397   Dali::Matrix3 *result = 0 ;
13398
13399   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13400   jresult = (void *)result;
13401   return jresult;
13402 }
13403
13404
13405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13406   void * jresult ;
13407   Dali::Matrix3 *result = 0 ;
13408
13409   {
13410     try {
13411       result = (Dali::Matrix3 *)new Dali::Matrix3();
13412     } catch (std::out_of_range& e) {
13413       {
13414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13415       };
13416     } catch (std::exception& e) {
13417       {
13418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13419       };
13420     } catch (Dali::DaliException e) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13423       };
13424     } catch (...) {
13425       {
13426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13427       };
13428     }
13429   }
13430
13431   jresult = (void *)result;
13432   return jresult;
13433 }
13434
13435
13436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13437   void * jresult ;
13438   Dali::Matrix3 *arg1 = 0 ;
13439   Dali::Matrix3 *result = 0 ;
13440
13441   arg1 = (Dali::Matrix3 *)jarg1;
13442   if (!arg1) {
13443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13444     return 0;
13445   }
13446   {
13447     try {
13448       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13449     } catch (std::out_of_range& e) {
13450       {
13451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13452       };
13453     } catch (std::exception& e) {
13454       {
13455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13456       };
13457     } catch (Dali::DaliException e) {
13458       {
13459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13460       };
13461     } catch (...) {
13462       {
13463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13464       };
13465     }
13466   }
13467
13468   jresult = (void *)result;
13469   return jresult;
13470 }
13471
13472
13473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13474   void * jresult ;
13475   Dali::Matrix *arg1 = 0 ;
13476   Dali::Matrix3 *result = 0 ;
13477
13478   arg1 = (Dali::Matrix *)jarg1;
13479   if (!arg1) {
13480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13481     return 0;
13482   }
13483   {
13484     try {
13485       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13486     } catch (std::out_of_range& e) {
13487       {
13488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (std::exception& e) {
13491       {
13492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13493       };
13494     } catch (Dali::DaliException e) {
13495       {
13496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13497       };
13498     } catch (...) {
13499       {
13500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13501       };
13502     }
13503   }
13504
13505   jresult = (void *)result;
13506   return jresult;
13507 }
13508
13509
13510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13511   void * jresult ;
13512   float arg1 ;
13513   float arg2 ;
13514   float arg3 ;
13515   float arg4 ;
13516   float arg5 ;
13517   float arg6 ;
13518   float arg7 ;
13519   float arg8 ;
13520   float arg9 ;
13521   Dali::Matrix3 *result = 0 ;
13522
13523   arg1 = (float)jarg1;
13524   arg2 = (float)jarg2;
13525   arg3 = (float)jarg3;
13526   arg4 = (float)jarg4;
13527   arg5 = (float)jarg5;
13528   arg6 = (float)jarg6;
13529   arg7 = (float)jarg7;
13530   arg8 = (float)jarg8;
13531   arg9 = (float)jarg9;
13532   {
13533     try {
13534       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13535     } catch (std::out_of_range& e) {
13536       {
13537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13538       };
13539     } catch (std::exception& e) {
13540       {
13541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13542       };
13543     } catch (Dali::DaliException e) {
13544       {
13545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13546       };
13547     } catch (...) {
13548       {
13549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13550       };
13551     }
13552   }
13553
13554   jresult = (void *)result;
13555   return jresult;
13556 }
13557
13558
13559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13560   void * jresult ;
13561   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13562   Dali::Matrix3 *arg2 = 0 ;
13563   Dali::Matrix3 *result = 0 ;
13564
13565   arg1 = (Dali::Matrix3 *)jarg1;
13566   arg2 = (Dali::Matrix3 *)jarg2;
13567   if (!arg2) {
13568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13569     return 0;
13570   }
13571   {
13572     try {
13573       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13574     } catch (std::out_of_range& e) {
13575       {
13576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13577       };
13578     } catch (std::exception& e) {
13579       {
13580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13581       };
13582     } catch (Dali::DaliException e) {
13583       {
13584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13585       };
13586     } catch (...) {
13587       {
13588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13589       };
13590     }
13591   }
13592
13593   jresult = (void *)result;
13594   return jresult;
13595 }
13596
13597
13598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13599   void * jresult ;
13600   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13601   Dali::Matrix *arg2 = 0 ;
13602   Dali::Matrix3 *result = 0 ;
13603
13604   arg1 = (Dali::Matrix3 *)jarg1;
13605   arg2 = (Dali::Matrix *)jarg2;
13606   if (!arg2) {
13607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13608     return 0;
13609   }
13610   {
13611     try {
13612       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13613     } catch (std::out_of_range& e) {
13614       {
13615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13616       };
13617     } catch (std::exception& e) {
13618       {
13619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13620       };
13621     } catch (Dali::DaliException e) {
13622       {
13623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13624       };
13625     } catch (...) {
13626       {
13627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13628       };
13629     }
13630   }
13631
13632   jresult = (void *)result;
13633   return jresult;
13634 }
13635
13636
13637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13638   unsigned int jresult ;
13639   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13640   Dali::Matrix3 *arg2 = 0 ;
13641   bool result;
13642
13643   arg1 = (Dali::Matrix3 *)jarg1;
13644   arg2 = (Dali::Matrix3 *)jarg2;
13645   if (!arg2) {
13646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13647     return 0;
13648   }
13649   {
13650     try {
13651       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13652     } catch (std::out_of_range& e) {
13653       {
13654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13655       };
13656     } catch (std::exception& e) {
13657       {
13658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13659       };
13660     } catch (Dali::DaliException e) {
13661       {
13662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13663       };
13664     } catch (...) {
13665       {
13666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13667       };
13668     }
13669   }
13670
13671   jresult = result;
13672   return jresult;
13673 }
13674
13675
13676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13677   unsigned int jresult ;
13678   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13679   Dali::Matrix3 *arg2 = 0 ;
13680   bool result;
13681
13682   arg1 = (Dali::Matrix3 *)jarg1;
13683   arg2 = (Dali::Matrix3 *)jarg2;
13684   if (!arg2) {
13685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13686     return 0;
13687   }
13688   {
13689     try {
13690       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13691     } catch (std::out_of_range& e) {
13692       {
13693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13694       };
13695     } catch (std::exception& e) {
13696       {
13697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13698       };
13699     } catch (Dali::DaliException e) {
13700       {
13701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13702       };
13703     } catch (...) {
13704       {
13705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13706       };
13707     }
13708   }
13709
13710   jresult = result;
13711   return jresult;
13712 }
13713
13714
13715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13716   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13717
13718   arg1 = (Dali::Matrix3 *)jarg1;
13719   {
13720     try {
13721       delete arg1;
13722     } catch (std::out_of_range& e) {
13723       {
13724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13725       };
13726     } catch (std::exception& e) {
13727       {
13728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13729       };
13730     } catch (Dali::DaliException e) {
13731       {
13732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13733       };
13734     } catch (...) {
13735       {
13736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13737       };
13738     }
13739   }
13740
13741 }
13742
13743
13744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13745   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13746
13747   arg1 = (Dali::Matrix3 *)jarg1;
13748   {
13749     try {
13750       (arg1)->SetIdentity();
13751     } catch (std::out_of_range& e) {
13752       {
13753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13754       };
13755     } catch (std::exception& e) {
13756       {
13757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13758       };
13759     } catch (Dali::DaliException e) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13762       };
13763     } catch (...) {
13764       {
13765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13766       };
13767     }
13768   }
13769
13770 }
13771
13772
13773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13774   void * jresult ;
13775   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13776   float *result = 0 ;
13777
13778   arg1 = (Dali::Matrix3 *)jarg1;
13779   {
13780     try {
13781       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13782     } catch (std::out_of_range& e) {
13783       {
13784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (std::exception& e) {
13787       {
13788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13789       };
13790     } catch (Dali::DaliException e) {
13791       {
13792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13793       };
13794     } catch (...) {
13795       {
13796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13797       };
13798     }
13799   }
13800
13801   jresult = (void *)result;
13802   return jresult;
13803 }
13804
13805
13806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13807   unsigned int jresult ;
13808   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13809   bool result;
13810
13811   arg1 = (Dali::Matrix3 *)jarg1;
13812   {
13813     try {
13814       result = (bool)(arg1)->Invert();
13815     } catch (std::out_of_range& e) {
13816       {
13817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13818       };
13819     } catch (std::exception& e) {
13820       {
13821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13822       };
13823     } catch (Dali::DaliException e) {
13824       {
13825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13826       };
13827     } catch (...) {
13828       {
13829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13830       };
13831     }
13832   }
13833
13834   jresult = result;
13835   return jresult;
13836 }
13837
13838
13839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13840   unsigned int jresult ;
13841   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13842   bool result;
13843
13844   arg1 = (Dali::Matrix3 *)jarg1;
13845   {
13846     try {
13847       result = (bool)(arg1)->Transpose();
13848     } catch (std::out_of_range& e) {
13849       {
13850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13851       };
13852     } catch (std::exception& e) {
13853       {
13854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13855       };
13856     } catch (Dali::DaliException e) {
13857       {
13858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13859       };
13860     } catch (...) {
13861       {
13862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13863       };
13864     }
13865   }
13866
13867   jresult = result;
13868   return jresult;
13869 }
13870
13871
13872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13873   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13874   float arg2 ;
13875
13876   arg1 = (Dali::Matrix3 *)jarg1;
13877   arg2 = (float)jarg2;
13878   {
13879     try {
13880       (arg1)->Scale(arg2);
13881     } catch (std::out_of_range& e) {
13882       {
13883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13884       };
13885     } catch (std::exception& e) {
13886       {
13887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13888       };
13889     } catch (Dali::DaliException e) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13892       };
13893     } catch (...) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13896       };
13897     }
13898   }
13899
13900 }
13901
13902
13903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13904   float jresult ;
13905   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13906   float result;
13907
13908   arg1 = (Dali::Matrix3 *)jarg1;
13909   {
13910     try {
13911       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13912     } catch (std::out_of_range& e) {
13913       {
13914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13915       };
13916     } catch (std::exception& e) {
13917       {
13918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13919       };
13920     } catch (Dali::DaliException e) {
13921       {
13922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13923       };
13924     } catch (...) {
13925       {
13926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13927       };
13928     }
13929   }
13930
13931   jresult = result;
13932   return jresult;
13933 }
13934
13935
13936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13937   unsigned int jresult ;
13938   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13939   bool result;
13940
13941   arg1 = (Dali::Matrix3 *)jarg1;
13942   {
13943     try {
13944       result = (bool)(arg1)->ScaledInverseTranspose();
13945     } catch (std::out_of_range& e) {
13946       {
13947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13948       };
13949     } catch (std::exception& e) {
13950       {
13951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13952       };
13953     } catch (Dali::DaliException e) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13956       };
13957     } catch (...) {
13958       {
13959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13960       };
13961     }
13962   }
13963
13964   jresult = result;
13965   return jresult;
13966 }
13967
13968
13969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13970   Dali::Matrix3 *arg1 = 0 ;
13971   Dali::Matrix3 *arg2 = 0 ;
13972   Dali::Matrix3 *arg3 = 0 ;
13973
13974   arg1 = (Dali::Matrix3 *)jarg1;
13975   if (!arg1) {
13976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13977     return ;
13978   }
13979   arg2 = (Dali::Matrix3 *)jarg2;
13980   if (!arg2) {
13981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13982     return ;
13983   }
13984   arg3 = (Dali::Matrix3 *)jarg3;
13985   if (!arg3) {
13986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13987     return ;
13988   }
13989   {
13990     try {
13991       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13992     } catch (std::out_of_range& e) {
13993       {
13994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13995       };
13996     } catch (std::exception& e) {
13997       {
13998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13999       };
14000     } catch (Dali::DaliException e) {
14001       {
14002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14003       };
14004     } catch (...) {
14005       {
14006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14007       };
14008     }
14009   }
14010
14011 }
14012
14013
14014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14015   float jresult ;
14016   float arg1 ;
14017   float arg2 ;
14018   float result;
14019
14020   arg1 = (float)jarg1;
14021   arg2 = (float)jarg2;
14022   {
14023     try {
14024       result = (float)Dali::Random::Range(arg1,arg2);
14025     } catch (std::out_of_range& e) {
14026       {
14027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14028       };
14029     } catch (std::exception& e) {
14030       {
14031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14032       };
14033     } catch (Dali::DaliException e) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14036       };
14037     } catch (...) {
14038       {
14039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14040       };
14041     }
14042   }
14043
14044   jresult = result;
14045   return jresult;
14046 }
14047
14048
14049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14050   void * jresult ;
14051   Dali::Vector4 result;
14052
14053   {
14054     try {
14055       result = Dali::Random::Axis();
14056     } catch (std::out_of_range& e) {
14057       {
14058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (std::exception& e) {
14061       {
14062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14063       };
14064     } catch (Dali::DaliException e) {
14065       {
14066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14067       };
14068     } catch (...) {
14069       {
14070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14071       };
14072     }
14073   }
14074
14075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14076   return jresult;
14077 }
14078
14079
14080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14081   void * jresult ;
14082   Dali::AngleAxis *result = 0 ;
14083
14084   {
14085     try {
14086       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14087     } catch (std::out_of_range& e) {
14088       {
14089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (std::exception& e) {
14092       {
14093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14094       };
14095     } catch (Dali::DaliException e) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14098       };
14099     } catch (...) {
14100       {
14101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14102       };
14103     }
14104   }
14105
14106   jresult = (void *)result;
14107   return jresult;
14108 }
14109
14110
14111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14112   void * jresult ;
14113   Dali::Radian arg1 ;
14114   Dali::Vector3 *arg2 = 0 ;
14115   Dali::Radian *argp1 ;
14116   Dali::AngleAxis *result = 0 ;
14117
14118   argp1 = (Dali::Radian *)jarg1;
14119   if (!argp1) {
14120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14121     return 0;
14122   }
14123   arg1 = *argp1;
14124   arg2 = (Dali::Vector3 *)jarg2;
14125   if (!arg2) {
14126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14127     return 0;
14128   }
14129   {
14130     try {
14131       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14132     } catch (std::out_of_range& e) {
14133       {
14134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14135       };
14136     } catch (std::exception& e) {
14137       {
14138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14139       };
14140     } catch (Dali::DaliException e) {
14141       {
14142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14143       };
14144     } catch (...) {
14145       {
14146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14147       };
14148     }
14149   }
14150
14151   jresult = (void *)result;
14152   return jresult;
14153 }
14154
14155
14156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14157   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14158   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14159
14160   arg1 = (Dali::AngleAxis *)jarg1;
14161   arg2 = (Dali::Radian *)jarg2;
14162   if (arg1) (arg1)->angle = *arg2;
14163 }
14164
14165
14166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14167   void * jresult ;
14168   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14169   Dali::Radian *result = 0 ;
14170
14171   arg1 = (Dali::AngleAxis *)jarg1;
14172   result = (Dali::Radian *)& ((arg1)->angle);
14173   jresult = (void *)result;
14174   return jresult;
14175 }
14176
14177
14178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14179   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14180   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14181
14182   arg1 = (Dali::AngleAxis *)jarg1;
14183   arg2 = (Dali::Vector3 *)jarg2;
14184   if (arg1) (arg1)->axis = *arg2;
14185 }
14186
14187
14188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14189   void * jresult ;
14190   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14191   Dali::Vector3 *result = 0 ;
14192
14193   arg1 = (Dali::AngleAxis *)jarg1;
14194   result = (Dali::Vector3 *)& ((arg1)->axis);
14195   jresult = (void *)result;
14196   return jresult;
14197 }
14198
14199
14200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14201   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14202
14203   arg1 = (Dali::AngleAxis *)jarg1;
14204   {
14205     try {
14206       delete arg1;
14207     } catch (std::out_of_range& e) {
14208       {
14209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14210       };
14211     } catch (std::exception& e) {
14212       {
14213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14214       };
14215     } catch (Dali::DaliException e) {
14216       {
14217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14218       };
14219     } catch (...) {
14220       {
14221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14222       };
14223     }
14224   }
14225
14226 }
14227
14228
14229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14230   unsigned int jresult ;
14231   Dali::AngleAxis *arg1 = 0 ;
14232   Dali::AngleAxis *arg2 = 0 ;
14233   bool result;
14234
14235   arg1 = (Dali::AngleAxis *)jarg1;
14236   if (!arg1) {
14237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14238     return 0;
14239   }
14240   arg2 = (Dali::AngleAxis *)jarg2;
14241   if (!arg2) {
14242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14243     return 0;
14244   }
14245   {
14246     try {
14247       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14255       };
14256     } catch (Dali::DaliException e) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14259       };
14260     } catch (...) {
14261       {
14262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14263       };
14264     }
14265   }
14266
14267   jresult = result;
14268   return jresult;
14269 }
14270
14271
14272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14273   unsigned int jresult ;
14274   unsigned int arg1 ;
14275   unsigned int result;
14276
14277   arg1 = (unsigned int)jarg1;
14278   {
14279     try {
14280       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14281     } catch (std::out_of_range& e) {
14282       {
14283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (std::exception& e) {
14286       {
14287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14288       };
14289     } catch (Dali::DaliException e) {
14290       {
14291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14292       };
14293     } catch (...) {
14294       {
14295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14296       };
14297     }
14298   }
14299
14300   jresult = result;
14301   return jresult;
14302 }
14303
14304
14305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14306   unsigned int jresult ;
14307   unsigned int arg1 ;
14308   bool result;
14309
14310   arg1 = (unsigned int)jarg1;
14311   {
14312     try {
14313       result = (bool)Dali::IsPowerOfTwo(arg1);
14314     } catch (std::out_of_range& e) {
14315       {
14316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14317       };
14318     } catch (std::exception& e) {
14319       {
14320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (Dali::DaliException e) {
14323       {
14324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332
14333   jresult = result;
14334   return jresult;
14335 }
14336
14337
14338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14339   float jresult ;
14340   float arg1 ;
14341   float arg2 ;
14342   float result;
14343
14344   arg1 = (float)jarg1;
14345   arg2 = (float)jarg2;
14346   {
14347     try {
14348       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14349     } catch (std::out_of_range& e) {
14350       {
14351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (std::exception& e) {
14354       {
14355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14356       };
14357     } catch (Dali::DaliException e) {
14358       {
14359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14360       };
14361     } catch (...) {
14362       {
14363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14364       };
14365     }
14366   }
14367
14368   jresult = result;
14369   return jresult;
14370 }
14371
14372
14373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14374   unsigned int jresult ;
14375   float arg1 ;
14376   bool result;
14377
14378   arg1 = (float)jarg1;
14379   {
14380     try {
14381       result = (bool)Dali::EqualsZero(arg1);
14382     } catch (std::out_of_range& e) {
14383       {
14384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (std::exception& e) {
14387       {
14388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14389       };
14390     } catch (Dali::DaliException e) {
14391       {
14392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14393       };
14394     } catch (...) {
14395       {
14396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14397       };
14398     }
14399   }
14400
14401   jresult = result;
14402   return jresult;
14403 }
14404
14405
14406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14407   unsigned int jresult ;
14408   float arg1 ;
14409   float arg2 ;
14410   bool result;
14411
14412   arg1 = (float)jarg1;
14413   arg2 = (float)jarg2;
14414   {
14415     try {
14416       result = (bool)Dali::Equals(arg1,arg2);
14417     } catch (std::out_of_range& e) {
14418       {
14419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14420       };
14421     } catch (std::exception& e) {
14422       {
14423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14424       };
14425     } catch (Dali::DaliException e) {
14426       {
14427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14428       };
14429     } catch (...) {
14430       {
14431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14432       };
14433     }
14434   }
14435
14436   jresult = result;
14437   return jresult;
14438 }
14439
14440
14441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14442   unsigned int jresult ;
14443   float arg1 ;
14444   float arg2 ;
14445   float arg3 ;
14446   bool result;
14447
14448   arg1 = (float)jarg1;
14449   arg2 = (float)jarg2;
14450   arg3 = (float)jarg3;
14451   {
14452     try {
14453       result = (bool)Dali::Equals(arg1,arg2,arg3);
14454     } catch (std::out_of_range& e) {
14455       {
14456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14457       };
14458     } catch (std::exception& e) {
14459       {
14460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14461       };
14462     } catch (Dali::DaliException e) {
14463       {
14464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14465       };
14466     } catch (...) {
14467       {
14468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14469       };
14470     }
14471   }
14472
14473   jresult = result;
14474   return jresult;
14475 }
14476
14477
14478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14479   float jresult ;
14480   float arg1 ;
14481   int arg2 ;
14482   float result;
14483
14484   arg1 = (float)jarg1;
14485   arg2 = (int)jarg2;
14486   {
14487     try {
14488       result = (float)Dali::Round(arg1,arg2);
14489     } catch (std::out_of_range& e) {
14490       {
14491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14492       };
14493     } catch (std::exception& e) {
14494       {
14495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14496       };
14497     } catch (Dali::DaliException e) {
14498       {
14499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14500       };
14501     } catch (...) {
14502       {
14503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14504       };
14505     }
14506   }
14507
14508   jresult = result;
14509   return jresult;
14510 }
14511
14512
14513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14514   float jresult ;
14515   float arg1 ;
14516   float arg2 ;
14517   float arg3 ;
14518   float result;
14519
14520   arg1 = (float)jarg1;
14521   arg2 = (float)jarg2;
14522   arg3 = (float)jarg3;
14523   {
14524     try {
14525       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14526     } catch (std::out_of_range& e) {
14527       {
14528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14529       };
14530     } catch (std::exception& e) {
14531       {
14532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14533       };
14534     } catch (Dali::DaliException e) {
14535       {
14536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14537       };
14538     } catch (...) {
14539       {
14540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14541       };
14542     }
14543   }
14544
14545   jresult = result;
14546   return jresult;
14547 }
14548
14549
14550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14551   float jresult ;
14552   float arg1 ;
14553   float arg2 ;
14554   float arg3 ;
14555   float arg4 ;
14556   float result;
14557
14558   arg1 = (float)jarg1;
14559   arg2 = (float)jarg2;
14560   arg3 = (float)jarg3;
14561   arg4 = (float)jarg4;
14562   {
14563     try {
14564       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14565     } catch (std::out_of_range& e) {
14566       {
14567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14568       };
14569     } catch (std::exception& e) {
14570       {
14571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14572       };
14573     } catch (Dali::DaliException e) {
14574       {
14575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14576       };
14577     } catch (...) {
14578       {
14579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14580       };
14581     }
14582   }
14583
14584   jresult = result;
14585   return jresult;
14586 }
14587
14588
14589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14590   int jresult ;
14591   int result;
14592
14593   result = (int)(int)Dali::Property::INVALID_INDEX;
14594   jresult = result;
14595   return jresult;
14596 }
14597
14598
14599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14600   int jresult ;
14601   int result;
14602
14603   result = (int)(int)Dali::Property::INVALID_KEY;
14604   jresult = result;
14605   return jresult;
14606 }
14607
14608
14609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14610   int jresult ;
14611   int result;
14612
14613   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14614   jresult = result;
14615   return jresult;
14616 }
14617
14618
14619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14620   void * jresult ;
14621   Dali::Handle *arg1 = 0 ;
14622   Dali::Property::Index arg2 ;
14623   Dali::Property *result = 0 ;
14624
14625   arg1 = (Dali::Handle *)jarg1;
14626   if (!arg1) {
14627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14628     return 0;
14629   }
14630   arg2 = (Dali::Property::Index)jarg2;
14631   {
14632     try {
14633       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14634     } catch (std::out_of_range& e) {
14635       {
14636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (std::exception& e) {
14639       {
14640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14641       };
14642     } catch (Dali::DaliException e) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14645       };
14646     } catch (...) {
14647       {
14648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14649       };
14650     }
14651   }
14652
14653   jresult = (void *)result;
14654   return jresult;
14655 }
14656
14657
14658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14659   void * jresult ;
14660   Dali::Handle *arg1 = 0 ;
14661   Dali::Property::Index arg2 ;
14662   int arg3 ;
14663   Dali::Property *result = 0 ;
14664
14665   arg1 = (Dali::Handle *)jarg1;
14666   if (!arg1) {
14667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14668     return 0;
14669   }
14670   arg2 = (Dali::Property::Index)jarg2;
14671   arg3 = (int)jarg3;
14672   {
14673     try {
14674       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14675     } catch (std::out_of_range& e) {
14676       {
14677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14678       };
14679     } catch (std::exception& e) {
14680       {
14681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14682       };
14683     } catch (Dali::DaliException e) {
14684       {
14685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14686       };
14687     } catch (...) {
14688       {
14689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14690       };
14691     }
14692   }
14693
14694   jresult = (void *)result;
14695   return jresult;
14696 }
14697
14698
14699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14700   void * jresult ;
14701   Dali::Handle *arg1 = 0 ;
14702   std::string *arg2 = 0 ;
14703   Dali::Property *result = 0 ;
14704
14705   arg1 = (Dali::Handle *)jarg1;
14706   if (!arg1) {
14707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14708     return 0;
14709   }
14710   if (!jarg2) {
14711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14712     return 0;
14713   }
14714   std::string arg2_str(jarg2);
14715   arg2 = &arg2_str;
14716   {
14717     try {
14718       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14719     } catch (std::out_of_range& e) {
14720       {
14721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (std::exception& e) {
14724       {
14725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (Dali::DaliException e) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14730       };
14731     } catch (...) {
14732       {
14733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14734       };
14735     }
14736   }
14737
14738   jresult = (void *)result;
14739
14740   //argout typemap for const std::string&
14741
14742   return jresult;
14743 }
14744
14745
14746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14747   void * jresult ;
14748   Dali::Handle *arg1 = 0 ;
14749   std::string *arg2 = 0 ;
14750   int arg3 ;
14751   Dali::Property *result = 0 ;
14752
14753   arg1 = (Dali::Handle *)jarg1;
14754   if (!arg1) {
14755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14756     return 0;
14757   }
14758   if (!jarg2) {
14759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14760     return 0;
14761   }
14762   std::string arg2_str(jarg2);
14763   arg2 = &arg2_str;
14764   arg3 = (int)jarg3;
14765   {
14766     try {
14767       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14768     } catch (std::out_of_range& e) {
14769       {
14770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (std::exception& e) {
14773       {
14774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14775       };
14776     } catch (Dali::DaliException e) {
14777       {
14778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14779       };
14780     } catch (...) {
14781       {
14782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14783       };
14784     }
14785   }
14786
14787   jresult = (void *)result;
14788
14789   //argout typemap for const std::string&
14790
14791   return jresult;
14792 }
14793
14794
14795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14796   Dali::Property *arg1 = (Dali::Property *) 0 ;
14797
14798   arg1 = (Dali::Property *)jarg1;
14799   {
14800     try {
14801       delete arg1;
14802     } catch (std::out_of_range& e) {
14803       {
14804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14805       };
14806     } catch (std::exception& e) {
14807       {
14808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14809       };
14810     } catch (Dali::DaliException e) {
14811       {
14812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14813       };
14814     } catch (...) {
14815       {
14816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14817       };
14818     }
14819   }
14820
14821 }
14822
14823
14824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14825   Dali::Property *arg1 = (Dali::Property *) 0 ;
14826   Dali::Handle *arg2 = 0 ;
14827
14828   arg1 = (Dali::Property *)jarg1;
14829   arg2 = (Dali::Handle *)jarg2;
14830   if (!arg2) {
14831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14832     return ;
14833   }
14834   if (arg1) (arg1)->object = *arg2;
14835 }
14836
14837
14838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14839   void * jresult ;
14840   Dali::Property *arg1 = (Dali::Property *) 0 ;
14841   Dali::Handle *result = 0 ;
14842
14843   arg1 = (Dali::Property *)jarg1;
14844   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14845   jresult = (void *)result;
14846   return jresult;
14847 }
14848
14849
14850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14851   Dali::Property *arg1 = (Dali::Property *) 0 ;
14852   Dali::Property::Index arg2 ;
14853
14854   arg1 = (Dali::Property *)jarg1;
14855   arg2 = (Dali::Property::Index)jarg2;
14856   if (arg1) (arg1)->propertyIndex = arg2;
14857 }
14858
14859
14860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14861   int jresult ;
14862   Dali::Property *arg1 = (Dali::Property *) 0 ;
14863   Dali::Property::Index result;
14864
14865   arg1 = (Dali::Property *)jarg1;
14866   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14867   jresult = result;
14868   return jresult;
14869 }
14870
14871
14872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14873   Dali::Property *arg1 = (Dali::Property *) 0 ;
14874   int arg2 ;
14875
14876   arg1 = (Dali::Property *)jarg1;
14877   arg2 = (int)jarg2;
14878   if (arg1) (arg1)->componentIndex = arg2;
14879 }
14880
14881
14882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14883   int jresult ;
14884   Dali::Property *arg1 = (Dali::Property *) 0 ;
14885   int result;
14886
14887   arg1 = (Dali::Property *)jarg1;
14888   result = (int) ((arg1)->componentIndex);
14889   jresult = result;
14890   return jresult;
14891 }
14892
14893
14894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14895   void * jresult ;
14896   Dali::Property::Array *result = 0 ;
14897
14898   {
14899     try {
14900       result = (Dali::Property::Array *)new Dali::Property::Array();
14901     } catch (std::out_of_range& e) {
14902       {
14903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14904       };
14905     } catch (std::exception& e) {
14906       {
14907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14908       };
14909     } catch (Dali::DaliException e) {
14910       {
14911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14912       };
14913     } catch (...) {
14914       {
14915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14916       };
14917     }
14918   }
14919
14920   jresult = (void *)result;
14921   return jresult;
14922 }
14923
14924
14925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14926   void * jresult ;
14927   Dali::Property::Array *arg1 = 0 ;
14928   Dali::Property::Array *result = 0 ;
14929
14930   arg1 = (Dali::Property::Array *)jarg1;
14931   if (!arg1) {
14932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14933     return 0;
14934   }
14935   {
14936     try {
14937       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14938     } catch (std::out_of_range& e) {
14939       {
14940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (std::exception& e) {
14943       {
14944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14945       };
14946     } catch (Dali::DaliException e) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14949       };
14950     } catch (...) {
14951       {
14952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14953       };
14954     }
14955   }
14956
14957   jresult = (void *)result;
14958   return jresult;
14959 }
14960
14961
14962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14963   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14964
14965   arg1 = (Dali::Property::Array *)jarg1;
14966   {
14967     try {
14968       delete arg1;
14969     } catch (std::out_of_range& e) {
14970       {
14971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14972       };
14973     } catch (std::exception& e) {
14974       {
14975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14976       };
14977     } catch (Dali::DaliException e) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14980       };
14981     } catch (...) {
14982       {
14983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14984       };
14985     }
14986   }
14987
14988 }
14989
14990
14991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14992   unsigned long jresult ;
14993   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14994   Dali::Property::Array::SizeType result;
14995
14996   arg1 = (Dali::Property::Array *)jarg1;
14997   {
14998     try {
14999       result = ((Dali::Property::Array const *)arg1)->Size();
15000     } catch (std::out_of_range& e) {
15001       {
15002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15003       };
15004     } catch (std::exception& e) {
15005       {
15006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (Dali::DaliException e) {
15009       {
15010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15011       };
15012     } catch (...) {
15013       {
15014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15015       };
15016     }
15017   }
15018
15019   jresult = (unsigned long)result;
15020   return jresult;
15021 }
15022
15023
15024 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15025   unsigned long jresult ;
15026   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15027   Dali::Property::Array::SizeType result;
15028
15029   arg1 = (Dali::Property::Array *)jarg1;
15030   {
15031     try {
15032       result = ((Dali::Property::Array const *)arg1)->Count();
15033     } catch (std::out_of_range& e) {
15034       {
15035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (std::exception& e) {
15038       {
15039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15040       };
15041     } catch (Dali::DaliException e) {
15042       {
15043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15044       };
15045     } catch (...) {
15046       {
15047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15048       };
15049     }
15050   }
15051
15052   jresult = (unsigned long)result;
15053   return jresult;
15054 }
15055
15056
15057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15058   unsigned int jresult ;
15059   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15060   bool result;
15061
15062   arg1 = (Dali::Property::Array *)jarg1;
15063   {
15064     try {
15065       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15066     } catch (std::out_of_range& e) {
15067       {
15068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (std::exception& e) {
15071       {
15072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15073       };
15074     } catch (Dali::DaliException e) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15077       };
15078     } catch (...) {
15079       {
15080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15081       };
15082     }
15083   }
15084
15085   jresult = result;
15086   return jresult;
15087 }
15088
15089
15090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15091   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15092
15093   arg1 = (Dali::Property::Array *)jarg1;
15094   {
15095     try {
15096       (arg1)->Clear();
15097     } catch (std::out_of_range& e) {
15098       {
15099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15100       };
15101     } catch (std::exception& e) {
15102       {
15103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15104       };
15105     } catch (Dali::DaliException e) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15108       };
15109     } catch (...) {
15110       {
15111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15112       };
15113     }
15114   }
15115
15116 }
15117
15118
15119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15120   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15121   Dali::Property::Array::SizeType arg2 ;
15122
15123   arg1 = (Dali::Property::Array *)jarg1;
15124   arg2 = (Dali::Property::Array::SizeType)jarg2;
15125   {
15126     try {
15127       (arg1)->Reserve(arg2);
15128     } catch (std::out_of_range& e) {
15129       {
15130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15131       };
15132     } catch (std::exception& e) {
15133       {
15134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15135       };
15136     } catch (Dali::DaliException e) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15143       };
15144     }
15145   }
15146
15147 }
15148
15149
15150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15151   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15152   Dali::Property::Array::SizeType arg2 ;
15153
15154   arg1 = (Dali::Property::Array *)jarg1;
15155   arg2 = (Dali::Property::Array::SizeType)jarg2;
15156   {
15157     try {
15158       (arg1)->Resize(arg2);
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15166       };
15167     } catch (Dali::DaliException e) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15170       };
15171     } catch (...) {
15172       {
15173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15174       };
15175     }
15176   }
15177
15178 }
15179
15180
15181 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15182   unsigned long jresult ;
15183   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15184   Dali::Property::Array::SizeType result;
15185
15186   arg1 = (Dali::Property::Array *)jarg1;
15187   {
15188     try {
15189       result = (arg1)->Capacity();
15190     } catch (std::out_of_range& e) {
15191       {
15192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15193       };
15194     } catch (std::exception& e) {
15195       {
15196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15197       };
15198     } catch (Dali::DaliException e) {
15199       {
15200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15201       };
15202     } catch (...) {
15203       {
15204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15205       };
15206     }
15207   }
15208
15209   jresult = (unsigned long)result;
15210   return jresult;
15211 }
15212
15213
15214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15215   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15216   Dali::Property::Value *arg2 = 0 ;
15217
15218   arg1 = (Dali::Property::Array *)jarg1;
15219   arg2 = (Dali::Property::Value *)jarg2;
15220   if (!arg2) {
15221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15222     return ;
15223   }
15224   {
15225     try {
15226       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15227     } catch (std::out_of_range& e) {
15228       {
15229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15230       };
15231     } catch (std::exception& e) {
15232       {
15233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15234       };
15235     } catch (Dali::DaliException e) {
15236       {
15237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15238       };
15239     } catch (...) {
15240       {
15241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15242       };
15243     }
15244   }
15245
15246 }
15247
15248
15249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15250   void * jresult ;
15251   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15252   Dali::Property::Value *arg2 = 0 ;
15253   Dali::Property::Array *result = 0 ;
15254
15255   arg1 = (Dali::Property::Array *)jarg1;
15256   arg2 = (Dali::Property::Value *)jarg2;
15257   if (!arg2) {
15258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15259     return 0;
15260   }
15261   {
15262     try {
15263       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15264     } catch (std::out_of_range& e) {
15265       {
15266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (std::exception& e) {
15269       {
15270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15271       };
15272     } catch (Dali::DaliException e) {
15273       {
15274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15275       };
15276     } catch (...) {
15277       {
15278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15279       };
15280     }
15281   }
15282
15283   jresult = (void *)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15289   void * jresult ;
15290   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15291   Dali::Property::Array::SizeType arg2 ;
15292   Dali::Property::Value *result = 0 ;
15293
15294   arg1 = (Dali::Property::Array *)jarg1;
15295   arg2 = (Dali::Property::Array::SizeType)jarg2;
15296   {
15297     try {
15298       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15299     } catch (std::out_of_range& e) {
15300       {
15301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (std::exception& e) {
15304       {
15305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (Dali::DaliException e) {
15308       {
15309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15310       };
15311     } catch (...) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15314       };
15315     }
15316   }
15317
15318   jresult = (void *)result;
15319   return jresult;
15320 }
15321
15322
15323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15324   void * jresult ;
15325   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15326   Dali::Property::Array::SizeType arg2 ;
15327   Dali::Property::Value *result = 0 ;
15328
15329   arg1 = (Dali::Property::Array *)jarg1;
15330   arg2 = (Dali::Property::Array::SizeType)jarg2;
15331   {
15332     try {
15333       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15334     } catch (std::out_of_range& e) {
15335       {
15336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15337       };
15338     } catch (std::exception& e) {
15339       {
15340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15341       };
15342     } catch (Dali::DaliException e) {
15343       {
15344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15345       };
15346     } catch (...) {
15347       {
15348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15349       };
15350     }
15351   }
15352
15353   jresult = (void *)result;
15354   return jresult;
15355 }
15356
15357
15358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15359   void * jresult ;
15360   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15361   Dali::Property::Array *arg2 = 0 ;
15362   Dali::Property::Array *result = 0 ;
15363
15364   arg1 = (Dali::Property::Array *)jarg1;
15365   arg2 = (Dali::Property::Array *)jarg2;
15366   if (!arg2) {
15367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15368     return 0;
15369   }
15370   {
15371     try {
15372       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15373     } catch (std::out_of_range& e) {
15374       {
15375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15376       };
15377     } catch (std::exception& e) {
15378       {
15379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15380       };
15381     } catch (Dali::DaliException e) {
15382       {
15383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15384       };
15385     } catch (...) {
15386       {
15387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15388       };
15389     }
15390   }
15391
15392   jresult = (void *)result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15398   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15399   enum Dali::Property::Key::Type arg2 ;
15400
15401   arg1 = (Dali::Property::Key *)jarg1;
15402   arg2 = (enum Dali::Property::Key::Type)jarg2;
15403   if (arg1) (arg1)->type = arg2;
15404 }
15405
15406
15407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15408   int jresult ;
15409   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15410   enum Dali::Property::Key::Type result;
15411
15412   arg1 = (Dali::Property::Key *)jarg1;
15413   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15414   jresult = (int)result;
15415   return jresult;
15416 }
15417
15418
15419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15420   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15421   Dali::Property::Index arg2 ;
15422
15423   arg1 = (Dali::Property::Key *)jarg1;
15424   arg2 = (Dali::Property::Index)jarg2;
15425   if (arg1) (arg1)->indexKey = arg2;
15426 }
15427
15428
15429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15430   int jresult ;
15431   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15432   Dali::Property::Index result;
15433
15434   arg1 = (Dali::Property::Key *)jarg1;
15435   result = (Dali::Property::Index) ((arg1)->indexKey);
15436   jresult = result;
15437   return jresult;
15438 }
15439
15440
15441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15442   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15443   std::string *arg2 = 0 ;
15444
15445   arg1 = (Dali::Property::Key *)jarg1;
15446   if (!jarg2) {
15447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15448     return ;
15449   }
15450   std::string arg2_str(jarg2);
15451   arg2 = &arg2_str;
15452   if (arg1) (arg1)->stringKey = *arg2;
15453
15454   //argout typemap for const std::string&
15455
15456 }
15457
15458
15459 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15460   char * jresult ;
15461   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15462   std::string *result = 0 ;
15463
15464   arg1 = (Dali::Property::Key *)jarg1;
15465   result = (std::string *) & ((arg1)->stringKey);
15466   jresult = SWIG_csharp_string_callback(result->c_str());
15467   return jresult;
15468 }
15469
15470
15471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15472   void * jresult ;
15473   std::string *arg1 = 0 ;
15474   Dali::Property::Key *result = 0 ;
15475
15476   if (!jarg1) {
15477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15478     return 0;
15479   }
15480   std::string arg1_str(jarg1);
15481   arg1 = &arg1_str;
15482   {
15483     try {
15484       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15485     } catch (std::out_of_range& e) {
15486       {
15487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15488       };
15489     } catch (std::exception& e) {
15490       {
15491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15492       };
15493     } catch (Dali::DaliException e) {
15494       {
15495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15496       };
15497     } catch (...) {
15498       {
15499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15500       };
15501     }
15502   }
15503
15504   jresult = (void *)result;
15505
15506   //argout typemap for const std::string&
15507
15508   return jresult;
15509 }
15510
15511
15512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15513   void * jresult ;
15514   Dali::Property::Index arg1 ;
15515   Dali::Property::Key *result = 0 ;
15516
15517   arg1 = (Dali::Property::Index)jarg1;
15518   {
15519     try {
15520       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15521     } catch (std::out_of_range& e) {
15522       {
15523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15524       };
15525     } catch (std::exception& e) {
15526       {
15527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15528       };
15529     } catch (Dali::DaliException e) {
15530       {
15531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15532       };
15533     } catch (...) {
15534       {
15535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15536       };
15537     }
15538   }
15539
15540   jresult = (void *)result;
15541   return jresult;
15542 }
15543
15544
15545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15546   unsigned int jresult ;
15547   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15548   std::string *arg2 = 0 ;
15549   bool result;
15550
15551   arg1 = (Dali::Property::Key *)jarg1;
15552   if (!jarg2) {
15553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15554     return 0;
15555   }
15556   std::string arg2_str(jarg2);
15557   arg2 = &arg2_str;
15558   {
15559     try {
15560       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15561     } catch (std::out_of_range& e) {
15562       {
15563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15564       };
15565     } catch (std::exception& e) {
15566       {
15567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15568       };
15569     } catch (Dali::DaliException e) {
15570       {
15571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15572       };
15573     } catch (...) {
15574       {
15575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15576       };
15577     }
15578   }
15579
15580   jresult = result;
15581
15582   //argout typemap for const std::string&
15583
15584   return jresult;
15585 }
15586
15587
15588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15589   unsigned int jresult ;
15590   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15591   Dali::Property::Index arg2 ;
15592   bool result;
15593
15594   arg1 = (Dali::Property::Key *)jarg1;
15595   arg2 = (Dali::Property::Index)jarg2;
15596   {
15597     try {
15598       result = (bool)(arg1)->operator ==(arg2);
15599     } catch (std::out_of_range& e) {
15600       {
15601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15602       };
15603     } catch (std::exception& e) {
15604       {
15605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15606       };
15607     } catch (Dali::DaliException e) {
15608       {
15609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15610       };
15611     } catch (...) {
15612       {
15613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15614       };
15615     }
15616   }
15617
15618   jresult = result;
15619   return jresult;
15620 }
15621
15622
15623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15624   unsigned int jresult ;
15625   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15626   Dali::Property::Key *arg2 = 0 ;
15627   bool result;
15628
15629   arg1 = (Dali::Property::Key *)jarg1;
15630   arg2 = (Dali::Property::Key *)jarg2;
15631   if (!arg2) {
15632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15633     return 0;
15634   }
15635   {
15636     try {
15637       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15638     } catch (std::out_of_range& e) {
15639       {
15640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (std::exception& e) {
15643       {
15644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (Dali::DaliException e) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15649       };
15650     } catch (...) {
15651       {
15652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15653       };
15654     }
15655   }
15656
15657   jresult = result;
15658   return jresult;
15659 }
15660
15661
15662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15663   unsigned int jresult ;
15664   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15665   std::string *arg2 = 0 ;
15666   bool result;
15667
15668   arg1 = (Dali::Property::Key *)jarg1;
15669   if (!jarg2) {
15670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15671     return 0;
15672   }
15673   std::string arg2_str(jarg2);
15674   arg2 = &arg2_str;
15675   {
15676     try {
15677       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15678     } catch (std::out_of_range& e) {
15679       {
15680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (std::exception& e) {
15683       {
15684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15685       };
15686     } catch (Dali::DaliException e) {
15687       {
15688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15689       };
15690     } catch (...) {
15691       {
15692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15693       };
15694     }
15695   }
15696
15697   jresult = result;
15698
15699   //argout typemap for const std::string&
15700
15701   return jresult;
15702 }
15703
15704
15705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15706   unsigned int jresult ;
15707   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15708   Dali::Property::Index arg2 ;
15709   bool result;
15710
15711   arg1 = (Dali::Property::Key *)jarg1;
15712   arg2 = (Dali::Property::Index)jarg2;
15713   {
15714     try {
15715       result = (bool)(arg1)->operator !=(arg2);
15716     } catch (std::out_of_range& e) {
15717       {
15718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (std::exception& e) {
15721       {
15722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15723       };
15724     } catch (Dali::DaliException e) {
15725       {
15726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15727       };
15728     } catch (...) {
15729       {
15730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15731       };
15732     }
15733   }
15734
15735   jresult = result;
15736   return jresult;
15737 }
15738
15739
15740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15741   unsigned int jresult ;
15742   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15743   Dali::Property::Key *arg2 = 0 ;
15744   bool result;
15745
15746   arg1 = (Dali::Property::Key *)jarg1;
15747   arg2 = (Dali::Property::Key *)jarg2;
15748   if (!arg2) {
15749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15750     return 0;
15751   }
15752   {
15753     try {
15754       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15755     } catch (std::out_of_range& e) {
15756       {
15757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15758       };
15759     } catch (std::exception& e) {
15760       {
15761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15762       };
15763     } catch (Dali::DaliException e) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15766       };
15767     } catch (...) {
15768       {
15769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15770       };
15771     }
15772   }
15773
15774   jresult = result;
15775   return jresult;
15776 }
15777
15778
15779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15780   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15781
15782   arg1 = (Dali::Property::Key *)jarg1;
15783   {
15784     try {
15785       delete arg1;
15786     } catch (std::out_of_range& e) {
15787       {
15788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15789       };
15790     } catch (std::exception& e) {
15791       {
15792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15793       };
15794     } catch (Dali::DaliException e) {
15795       {
15796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15797       };
15798     } catch (...) {
15799       {
15800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15801       };
15802     }
15803   }
15804
15805 }
15806
15807
15808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15809   void * jresult ;
15810   Dali::Property::Map *result = 0 ;
15811
15812   {
15813     try {
15814       result = (Dali::Property::Map *)new Dali::Property::Map();
15815     } catch (std::out_of_range& e) {
15816       {
15817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15818       };
15819     } catch (std::exception& e) {
15820       {
15821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15822       };
15823     } catch (Dali::DaliException e) {
15824       {
15825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15826       };
15827     } catch (...) {
15828       {
15829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15830       };
15831     }
15832   }
15833
15834   jresult = (void *)result;
15835   return jresult;
15836 }
15837
15838
15839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15840   void * jresult ;
15841   Dali::Property::Map *arg1 = 0 ;
15842   Dali::Property::Map *result = 0 ;
15843
15844   arg1 = (Dali::Property::Map *)jarg1;
15845   if (!arg1) {
15846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15847     return 0;
15848   }
15849   {
15850     try {
15851       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15852     } catch (std::out_of_range& e) {
15853       {
15854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (std::exception& e) {
15857       {
15858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15859       };
15860     } catch (Dali::DaliException e) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15863       };
15864     } catch (...) {
15865       {
15866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15867       };
15868     }
15869   }
15870
15871   jresult = (void *)result;
15872   return jresult;
15873 }
15874
15875
15876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15877   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15878
15879   arg1 = (Dali::Property::Map *)jarg1;
15880   {
15881     try {
15882       delete arg1;
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15890       };
15891     } catch (Dali::DaliException e) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15894       };
15895     } catch (...) {
15896       {
15897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15898       };
15899     }
15900   }
15901
15902 }
15903
15904
15905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15906   unsigned long jresult ;
15907   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15908   Dali::Property::Map::SizeType result;
15909
15910   arg1 = (Dali::Property::Map *)jarg1;
15911   {
15912     try {
15913       result = ((Dali::Property::Map const *)arg1)->Count();
15914     } catch (std::out_of_range& e) {
15915       {
15916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15917       };
15918     } catch (std::exception& e) {
15919       {
15920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15921       };
15922     } catch (Dali::DaliException e) {
15923       {
15924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15925       };
15926     } catch (...) {
15927       {
15928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15929       };
15930     }
15931   }
15932
15933   jresult = (unsigned long)result;
15934   return jresult;
15935 }
15936
15937
15938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15939   unsigned int jresult ;
15940   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15941   bool result;
15942
15943   arg1 = (Dali::Property::Map *)jarg1;
15944   {
15945     try {
15946       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15947     } catch (std::out_of_range& e) {
15948       {
15949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15950       };
15951     } catch (std::exception& e) {
15952       {
15953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15954       };
15955     } catch (Dali::DaliException e) {
15956       {
15957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15958       };
15959     } catch (...) {
15960       {
15961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15962       };
15963     }
15964   }
15965
15966   jresult = result;
15967   return jresult;
15968 }
15969
15970
15971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15972   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15973   char *arg2 = (char *) 0 ;
15974   Dali::Property::Value *arg3 = 0 ;
15975
15976   arg1 = (Dali::Property::Map *)jarg1;
15977   arg2 = (char *)jarg2;
15978   arg3 = (Dali::Property::Value *)jarg3;
15979   if (!arg3) {
15980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15981     return ;
15982   }
15983   {
15984     try {
15985       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15986     } catch (std::out_of_range& e) {
15987       {
15988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15989       };
15990     } catch (std::exception& e) {
15991       {
15992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15993       };
15994     } catch (Dali::DaliException e) {
15995       {
15996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15997       };
15998     } catch (...) {
15999       {
16000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16001       };
16002     }
16003   }
16004
16005 }
16006
16007
16008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16009   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16010   Dali::Property::Index arg2 ;
16011   Dali::Property::Value *arg3 = 0 ;
16012
16013   arg1 = (Dali::Property::Map *)jarg1;
16014   arg2 = (Dali::Property::Index)jarg2;
16015   arg3 = (Dali::Property::Value *)jarg3;
16016   if (!arg3) {
16017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16018     return ;
16019   }
16020   {
16021     try {
16022       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16023     } catch (std::out_of_range& e) {
16024       {
16025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16026       };
16027     } catch (std::exception& e) {
16028       {
16029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16030       };
16031     } catch (Dali::DaliException e) {
16032       {
16033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16034       };
16035     } catch (...) {
16036       {
16037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16038       };
16039     }
16040   }
16041
16042 }
16043
16044
16045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16046   void * jresult ;
16047   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16048   char *arg2 = (char *) 0 ;
16049   Dali::Property::Value *arg3 = 0 ;
16050   Dali::Property::Map *result = 0 ;
16051
16052   arg1 = (Dali::Property::Map *)jarg1;
16053   arg2 = (char *)jarg2;
16054   arg3 = (Dali::Property::Value *)jarg3;
16055   if (!arg3) {
16056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16057     return 0;
16058   }
16059   {
16060     try {
16061       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16062     } catch (std::out_of_range& e) {
16063       {
16064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (std::exception& e) {
16067       {
16068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16069       };
16070     } catch (Dali::DaliException e) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16073       };
16074     } catch (...) {
16075       {
16076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16077       };
16078     }
16079   }
16080
16081   jresult = (void *)result;
16082   return jresult;
16083 }
16084
16085
16086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16087   void * jresult ;
16088   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16089   Dali::Property::Index arg2 ;
16090   Dali::Property::Value *arg3 = 0 ;
16091   Dali::Property::Map *result = 0 ;
16092
16093   arg1 = (Dali::Property::Map *)jarg1;
16094   arg2 = (Dali::Property::Index)jarg2;
16095   arg3 = (Dali::Property::Value *)jarg3;
16096   if (!arg3) {
16097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16098     return 0;
16099   }
16100   {
16101     try {
16102       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16103     } catch (std::out_of_range& e) {
16104       {
16105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16106       };
16107     } catch (std::exception& e) {
16108       {
16109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16110       };
16111     } catch (Dali::DaliException e) {
16112       {
16113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16114       };
16115     } catch (...) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16118       };
16119     }
16120   }
16121
16122   jresult = (void *)result;
16123   return jresult;
16124 }
16125
16126
16127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16128   void * jresult ;
16129   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16130   Dali::Property::Map::SizeType arg2 ;
16131   Dali::Property::Value *result = 0 ;
16132
16133   arg1 = (Dali::Property::Map *)jarg1;
16134   arg2 = (Dali::Property::Map::SizeType)jarg2;
16135   {
16136     try {
16137       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16138     } catch (std::out_of_range& e) {
16139       {
16140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (std::exception& e) {
16143       {
16144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (Dali::DaliException e) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16149       };
16150     } catch (...) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16153       };
16154     }
16155   }
16156
16157   jresult = (void *)result;
16158   return jresult;
16159 }
16160
16161
16162 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16163   char * jresult ;
16164   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16165   Dali::Property::Map::SizeType arg2 ;
16166   std::string *result = 0 ;
16167
16168   arg1 = (Dali::Property::Map *)jarg1;
16169   arg2 = (Dali::Property::Map::SizeType)jarg2;
16170   {
16171     try {
16172       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16173     } catch (std::out_of_range& e) {
16174       {
16175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16176       };
16177     } catch (std::exception& e) {
16178       {
16179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16180       };
16181     } catch (Dali::DaliException e) {
16182       {
16183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16184       };
16185     } catch (...) {
16186       {
16187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16188       };
16189     }
16190   }
16191
16192   jresult = SWIG_csharp_string_callback(result->c_str());
16193   return jresult;
16194 }
16195
16196
16197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16198   void * jresult ;
16199   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16200   Dali::Property::Map::SizeType arg2 ;
16201   SwigValueWrapper< Dali::Property::Key > result;
16202
16203   arg1 = (Dali::Property::Map *)jarg1;
16204   arg2 = (Dali::Property::Map::SizeType)jarg2;
16205   {
16206     try {
16207       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16208     } catch (std::out_of_range& e) {
16209       {
16210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16211       };
16212     } catch (std::exception& e) {
16213       {
16214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16215       };
16216     } catch (Dali::DaliException e) {
16217       {
16218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16219       };
16220     } catch (...) {
16221       {
16222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16223       };
16224     }
16225   }
16226
16227   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16228   return jresult;
16229 }
16230
16231
16232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16233   void * jresult ;
16234   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16235   Dali::Property::Map::SizeType arg2 ;
16236   StringValuePair *result = 0 ;
16237
16238   arg1 = (Dali::Property::Map *)jarg1;
16239   arg2 = (Dali::Property::Map::SizeType)jarg2;
16240   {
16241     try {
16242       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16243     } catch (std::out_of_range& e) {
16244       {
16245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16246       };
16247     } catch (std::exception& e) {
16248       {
16249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16250       };
16251     } catch (Dali::DaliException e) {
16252       {
16253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16254       };
16255     } catch (...) {
16256       {
16257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16258       };
16259     }
16260   }
16261
16262   jresult = (void *)result;
16263   return jresult;
16264 }
16265
16266
16267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16268   void * jresult ;
16269   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16270   char *arg2 = (char *) 0 ;
16271   Dali::Property::Value *result = 0 ;
16272
16273   arg1 = (Dali::Property::Map *)jarg1;
16274   arg2 = (char *)jarg2;
16275   {
16276     try {
16277       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16278     } catch (std::out_of_range& e) {
16279       {
16280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (std::exception& e) {
16283       {
16284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16285       };
16286     } catch (Dali::DaliException e) {
16287       {
16288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16289       };
16290     } catch (...) {
16291       {
16292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16293       };
16294     }
16295   }
16296
16297   jresult = (void *)result;
16298   return jresult;
16299 }
16300
16301
16302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16303   void * jresult ;
16304   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16305   Dali::Property::Index arg2 ;
16306   Dali::Property::Value *result = 0 ;
16307
16308   arg1 = (Dali::Property::Map *)jarg1;
16309   arg2 = (Dali::Property::Index)jarg2;
16310   {
16311     try {
16312       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16313     } catch (std::out_of_range& e) {
16314       {
16315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16316       };
16317     } catch (std::exception& e) {
16318       {
16319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16320       };
16321     } catch (Dali::DaliException e) {
16322       {
16323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16324       };
16325     } catch (...) {
16326       {
16327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16328       };
16329     }
16330   }
16331
16332   jresult = (void *)result;
16333   return jresult;
16334 }
16335
16336
16337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16338   void * jresult ;
16339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16340   Dali::Property::Index arg2 ;
16341   std::string *arg3 = 0 ;
16342   Dali::Property::Value *result = 0 ;
16343
16344   arg1 = (Dali::Property::Map *)jarg1;
16345   arg2 = (Dali::Property::Index)jarg2;
16346   if (!jarg3) {
16347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16348     return 0;
16349   }
16350   std::string arg3_str(jarg3);
16351   arg3 = &arg3_str;
16352   {
16353     try {
16354       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16355     } catch (std::out_of_range& e) {
16356       {
16357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (std::exception& e) {
16360       {
16361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (Dali::DaliException e) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16366       };
16367     } catch (...) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16370       };
16371     }
16372   }
16373
16374   jresult = (void *)result;
16375
16376   //argout typemap for const std::string&
16377
16378   return jresult;
16379 }
16380
16381
16382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16383   void * jresult ;
16384   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16385   std::string *arg2 = 0 ;
16386   Dali::Property::Type arg3 ;
16387   Dali::Property::Value *result = 0 ;
16388
16389   arg1 = (Dali::Property::Map *)jarg1;
16390   if (!jarg2) {
16391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16392     return 0;
16393   }
16394   std::string arg2_str(jarg2);
16395   arg2 = &arg2_str;
16396   arg3 = (Dali::Property::Type)jarg3;
16397   {
16398     try {
16399       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16400     } catch (std::out_of_range& e) {
16401       {
16402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16403       };
16404     } catch (std::exception& e) {
16405       {
16406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16407       };
16408     } catch (Dali::DaliException e) {
16409       {
16410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16411       };
16412     } catch (...) {
16413       {
16414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16415       };
16416     }
16417   }
16418
16419   jresult = (void *)result;
16420
16421   //argout typemap for const std::string&
16422
16423   return jresult;
16424 }
16425
16426
16427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16428   void * jresult ;
16429   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16430   Dali::Property::Index arg2 ;
16431   Dali::Property::Type arg3 ;
16432   Dali::Property::Value *result = 0 ;
16433
16434   arg1 = (Dali::Property::Map *)jarg1;
16435   arg2 = (Dali::Property::Index)jarg2;
16436   arg3 = (Dali::Property::Type)jarg3;
16437   {
16438     try {
16439       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16440     } catch (std::out_of_range& e) {
16441       {
16442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16443       };
16444     } catch (std::exception& e) {
16445       {
16446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16447       };
16448     } catch (Dali::DaliException e) {
16449       {
16450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16451       };
16452     } catch (...) {
16453       {
16454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16455       };
16456     }
16457   }
16458
16459   jresult = (void *)result;
16460   return jresult;
16461 }
16462
16463
16464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16465   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16466
16467   arg1 = (Dali::Property::Map *)jarg1;
16468   {
16469     try {
16470       (arg1)->Clear();
16471     } catch (std::out_of_range& e) {
16472       {
16473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16474       };
16475     } catch (std::exception& e) {
16476       {
16477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16478       };
16479     } catch (Dali::DaliException e) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16482       };
16483     } catch (...) {
16484       {
16485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16486       };
16487     }
16488   }
16489
16490 }
16491
16492
16493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16494   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16495   Dali::Property::Map *arg2 = 0 ;
16496
16497   arg1 = (Dali::Property::Map *)jarg1;
16498   arg2 = (Dali::Property::Map *)jarg2;
16499   if (!arg2) {
16500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16501     return ;
16502   }
16503   {
16504     try {
16505       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16506     } catch (std::out_of_range& e) {
16507       {
16508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16509       };
16510     } catch (std::exception& e) {
16511       {
16512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16513       };
16514     } catch (Dali::DaliException e) {
16515       {
16516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16517       };
16518     } catch (...) {
16519       {
16520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16521       };
16522     }
16523   }
16524
16525 }
16526
16527
16528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16529   void * jresult ;
16530   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16531   std::string *arg2 = 0 ;
16532   Dali::Property::Value *result = 0 ;
16533
16534   arg1 = (Dali::Property::Map *)jarg1;
16535   if (!jarg2) {
16536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16537     return 0;
16538   }
16539   std::string arg2_str(jarg2);
16540   arg2 = &arg2_str;
16541   {
16542     try {
16543       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16544     } catch (std::out_of_range& e) {
16545       {
16546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16547       };
16548     } catch (std::exception& e) {
16549       {
16550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16551       };
16552     } catch (Dali::DaliException e) {
16553       {
16554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16555       };
16556     } catch (...) {
16557       {
16558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16559       };
16560     }
16561   }
16562
16563   jresult = (void *)result;
16564
16565   //argout typemap for const std::string&
16566
16567   return jresult;
16568 }
16569
16570
16571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16572   void * jresult ;
16573   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16574   Dali::Property::Index arg2 ;
16575   Dali::Property::Value *result = 0 ;
16576
16577   arg1 = (Dali::Property::Map *)jarg1;
16578   arg2 = (Dali::Property::Index)jarg2;
16579   {
16580     try {
16581       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16582     } catch (std::out_of_range& e) {
16583       {
16584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16585       };
16586     } catch (std::exception& e) {
16587       {
16588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16589       };
16590     } catch (Dali::DaliException e) {
16591       {
16592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16593       };
16594     } catch (...) {
16595       {
16596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16597       };
16598     }
16599   }
16600
16601   jresult = (void *)result;
16602   return jresult;
16603 }
16604
16605
16606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16607   void * jresult ;
16608   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16609   Dali::Property::Map *arg2 = 0 ;
16610   Dali::Property::Map *result = 0 ;
16611
16612   arg1 = (Dali::Property::Map *)jarg1;
16613   arg2 = (Dali::Property::Map *)jarg2;
16614   if (!arg2) {
16615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16616     return 0;
16617   }
16618   {
16619     try {
16620       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16621     } catch (std::out_of_range& e) {
16622       {
16623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16624       };
16625     } catch (std::exception& e) {
16626       {
16627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16628       };
16629     } catch (Dali::DaliException e) {
16630       {
16631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16632       };
16633     } catch (...) {
16634       {
16635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16636       };
16637     }
16638   }
16639
16640   jresult = (void *)result;
16641   return jresult;
16642 }
16643
16644
16645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16646   void * jresult ;
16647   Dali::Property::Value *result = 0 ;
16648
16649   {
16650     try {
16651       result = (Dali::Property::Value *)new Dali::Property::Value();
16652     } catch (std::out_of_range& e) {
16653       {
16654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16655       };
16656     } catch (std::exception& e) {
16657       {
16658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16659       };
16660     } catch (Dali::DaliException e) {
16661       {
16662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16663       };
16664     } catch (...) {
16665       {
16666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16667       };
16668     }
16669   }
16670
16671   jresult = (void *)result;
16672   return jresult;
16673 }
16674
16675
16676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16677   void * jresult ;
16678   bool arg1 ;
16679   Dali::Property::Value *result = 0 ;
16680
16681   arg1 = jarg1 ? true : false;
16682   {
16683     try {
16684       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16685     } catch (std::out_of_range& e) {
16686       {
16687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16688       };
16689     } catch (std::exception& e) {
16690       {
16691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16692       };
16693     } catch (Dali::DaliException e) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16696       };
16697     } catch (...) {
16698       {
16699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16700       };
16701     }
16702   }
16703
16704   jresult = (void *)result;
16705   return jresult;
16706 }
16707
16708
16709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16710   void * jresult ;
16711   int arg1 ;
16712   Dali::Property::Value *result = 0 ;
16713
16714   arg1 = (int)jarg1;
16715   {
16716     try {
16717       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16718     } catch (std::out_of_range& e) {
16719       {
16720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16721       };
16722     } catch (std::exception& e) {
16723       {
16724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16725       };
16726     } catch (Dali::DaliException e) {
16727       {
16728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16729       };
16730     } catch (...) {
16731       {
16732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16733       };
16734     }
16735   }
16736
16737   jresult = (void *)result;
16738   return jresult;
16739 }
16740
16741
16742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16743   void * jresult ;
16744   float arg1 ;
16745   Dali::Property::Value *result = 0 ;
16746
16747   arg1 = (float)jarg1;
16748   {
16749     try {
16750       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16751     } catch (std::out_of_range& e) {
16752       {
16753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16754       };
16755     } catch (std::exception& e) {
16756       {
16757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16758       };
16759     } catch (Dali::DaliException e) {
16760       {
16761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16762       };
16763     } catch (...) {
16764       {
16765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16766       };
16767     }
16768   }
16769
16770   jresult = (void *)result;
16771   return jresult;
16772 }
16773
16774
16775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16776   void * jresult ;
16777   Dali::Vector2 *arg1 = 0 ;
16778   Dali::Property::Value *result = 0 ;
16779
16780   arg1 = (Dali::Vector2 *)jarg1;
16781   if (!arg1) {
16782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16783     return 0;
16784   }
16785   {
16786     try {
16787       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16788     } catch (std::out_of_range& e) {
16789       {
16790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16791       };
16792     } catch (std::exception& e) {
16793       {
16794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16795       };
16796     } catch (Dali::DaliException e) {
16797       {
16798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16799       };
16800     } catch (...) {
16801       {
16802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16803       };
16804     }
16805   }
16806
16807   jresult = (void *)result;
16808   return jresult;
16809 }
16810
16811
16812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16813   void * jresult ;
16814   Dali::Vector3 *arg1 = 0 ;
16815   Dali::Property::Value *result = 0 ;
16816
16817   arg1 = (Dali::Vector3 *)jarg1;
16818   if (!arg1) {
16819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16820     return 0;
16821   }
16822   {
16823     try {
16824       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16825     } catch (std::out_of_range& e) {
16826       {
16827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (std::exception& e) {
16830       {
16831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16832       };
16833     } catch (Dali::DaliException e) {
16834       {
16835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16836       };
16837     } catch (...) {
16838       {
16839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16840       };
16841     }
16842   }
16843
16844   jresult = (void *)result;
16845   return jresult;
16846 }
16847
16848
16849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16850   void * jresult ;
16851   Dali::Vector4 *arg1 = 0 ;
16852   Dali::Property::Value *result = 0 ;
16853
16854   arg1 = (Dali::Vector4 *)jarg1;
16855   if (!arg1) {
16856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16857     return 0;
16858   }
16859   {
16860     try {
16861       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16862     } catch (std::out_of_range& e) {
16863       {
16864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (std::exception& e) {
16867       {
16868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16869       };
16870     } catch (Dali::DaliException e) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16873       };
16874     } catch (...) {
16875       {
16876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16877       };
16878     }
16879   }
16880
16881   jresult = (void *)result;
16882   return jresult;
16883 }
16884
16885
16886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16887   void * jresult ;
16888   Dali::Matrix3 *arg1 = 0 ;
16889   Dali::Property::Value *result = 0 ;
16890
16891   arg1 = (Dali::Matrix3 *)jarg1;
16892   if (!arg1) {
16893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16894     return 0;
16895   }
16896   {
16897     try {
16898       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16899     } catch (std::out_of_range& e) {
16900       {
16901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (std::exception& e) {
16904       {
16905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16906       };
16907     } catch (Dali::DaliException e) {
16908       {
16909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16910       };
16911     } catch (...) {
16912       {
16913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16914       };
16915     }
16916   }
16917
16918   jresult = (void *)result;
16919   return jresult;
16920 }
16921
16922
16923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16924   void * jresult ;
16925   Dali::Matrix *arg1 = 0 ;
16926   Dali::Property::Value *result = 0 ;
16927
16928   arg1 = (Dali::Matrix *)jarg1;
16929   if (!arg1) {
16930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16931     return 0;
16932   }
16933   {
16934     try {
16935       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16936     } catch (std::out_of_range& e) {
16937       {
16938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (std::exception& e) {
16941       {
16942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16943       };
16944     } catch (Dali::DaliException e) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16947       };
16948     } catch (...) {
16949       {
16950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16951       };
16952     }
16953   }
16954
16955   jresult = (void *)result;
16956   return jresult;
16957 }
16958
16959
16960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16961   void * jresult ;
16962   Dali::Rect< int > *arg1 = 0 ;
16963   Dali::Property::Value *result = 0 ;
16964
16965   arg1 = (Dali::Rect< int > *)jarg1;
16966   if (!arg1) {
16967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16968     return 0;
16969   }
16970   {
16971     try {
16972       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16973     } catch (std::out_of_range& e) {
16974       {
16975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (std::exception& e) {
16978       {
16979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (Dali::DaliException e) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991
16992   jresult = (void *)result;
16993   return jresult;
16994 }
16995
16996
16997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16998   void * jresult ;
16999   Dali::AngleAxis *arg1 = 0 ;
17000   Dali::Property::Value *result = 0 ;
17001
17002   arg1 = (Dali::AngleAxis *)jarg1;
17003   if (!arg1) {
17004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17005     return 0;
17006   }
17007   {
17008     try {
17009       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (Dali::DaliException e) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17021       };
17022     } catch (...) {
17023       {
17024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17025       };
17026     }
17027   }
17028
17029   jresult = (void *)result;
17030   return jresult;
17031 }
17032
17033
17034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17035   void * jresult ;
17036   Dali::Quaternion *arg1 = 0 ;
17037   Dali::Property::Value *result = 0 ;
17038
17039   arg1 = (Dali::Quaternion *)jarg1;
17040   if (!arg1) {
17041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17042     return 0;
17043   }
17044   {
17045     try {
17046       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (Dali::DaliException e) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17058       };
17059     } catch (...) {
17060       {
17061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17062       };
17063     }
17064   }
17065
17066   jresult = (void *)result;
17067   return jresult;
17068 }
17069
17070
17071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17072   void * jresult ;
17073   std::string *arg1 = 0 ;
17074   Dali::Property::Value *result = 0 ;
17075
17076   if (!jarg1) {
17077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17078     return 0;
17079   }
17080   std::string arg1_str(jarg1);
17081   arg1 = &arg1_str;
17082   {
17083     try {
17084       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17085     } catch (std::out_of_range& e) {
17086       {
17087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17088       };
17089     } catch (std::exception& e) {
17090       {
17091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17092       };
17093     } catch (Dali::DaliException e) {
17094       {
17095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17096       };
17097     } catch (...) {
17098       {
17099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17100       };
17101     }
17102   }
17103
17104   jresult = (void *)result;
17105
17106   //argout typemap for const std::string&
17107
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17113   void * jresult ;
17114   Dali::Property::Array *arg1 = 0 ;
17115   Dali::Property::Value *result = 0 ;
17116
17117   arg1 = (Dali::Property::Array *)jarg1;
17118   if (!arg1) {
17119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17120     return 0;
17121   }
17122   {
17123     try {
17124       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17125     } catch (std::out_of_range& e) {
17126       {
17127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (std::exception& e) {
17130       {
17131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17132       };
17133     } catch (Dali::DaliException e) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17136       };
17137     } catch (...) {
17138       {
17139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17140       };
17141     }
17142   }
17143
17144   jresult = (void *)result;
17145   return jresult;
17146 }
17147
17148
17149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17150   void * jresult ;
17151   Dali::Property::Map *arg1 = 0 ;
17152   Dali::Property::Value *result = 0 ;
17153
17154   arg1 = (Dali::Property::Map *)jarg1;
17155   if (!arg1) {
17156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17157     return 0;
17158   }
17159   {
17160     try {
17161       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17162     } catch (std::out_of_range& e) {
17163       {
17164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (std::exception& e) {
17167       {
17168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17169       };
17170     } catch (Dali::DaliException e) {
17171       {
17172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17173       };
17174     } catch (...) {
17175       {
17176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17177       };
17178     }
17179   }
17180
17181   jresult = (void *)result;
17182   return jresult;
17183 }
17184
17185
17186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17187   void * jresult ;
17188   Extents *arg1 = 0 ;
17189   Dali::Property::Value *result = 0 ;
17190
17191   arg1 = (Extents *)jarg1;
17192   if (!arg1) {
17193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17194     return 0;
17195   }
17196   {
17197     try {
17198       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17199     } catch (std::out_of_range& e) {
17200       {
17201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (std::exception& e) {
17204       {
17205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17206       };
17207     } catch (...) {
17208       {
17209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17210       };
17211     }
17212   }
17213   jresult = (void *)result;
17214   return jresult;
17215 }
17216
17217
17218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17219   void * jresult ;
17220   Dali::Property::Type arg1 ;
17221   Dali::Property::Value *result = 0 ;
17222
17223   arg1 = (Dali::Property::Type)jarg1;
17224   {
17225     try {
17226       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17227     } catch (std::out_of_range& e) {
17228       {
17229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (std::exception& e) {
17232       {
17233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (Dali::DaliException e) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17238       };
17239     } catch (...) {
17240       {
17241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17242       };
17243     }
17244   }
17245
17246   jresult = (void *)result;
17247   return jresult;
17248 }
17249
17250
17251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17252   void * jresult ;
17253   Dali::Property::Value *arg1 = 0 ;
17254   Dali::Property::Value *result = 0 ;
17255
17256   arg1 = (Dali::Property::Value *)jarg1;
17257   if (!arg1) {
17258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17259     return 0;
17260   }
17261   {
17262     try {
17263       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17264     } catch (std::out_of_range& e) {
17265       {
17266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17267       };
17268     } catch (std::exception& e) {
17269       {
17270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17271       };
17272     } catch (Dali::DaliException e) {
17273       {
17274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17275       };
17276     } catch (...) {
17277       {
17278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17279       };
17280     }
17281   }
17282
17283   jresult = (void *)result;
17284   return jresult;
17285 }
17286
17287
17288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17289   void * jresult ;
17290   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17291   Dali::Property::Value *arg2 = 0 ;
17292   Dali::Property::Value *result = 0 ;
17293
17294   arg1 = (Dali::Property::Value *)jarg1;
17295   arg2 = (Dali::Property::Value *)jarg2;
17296   if (!arg2) {
17297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17298     return 0;
17299   }
17300   {
17301     try {
17302       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17303     } catch (std::out_of_range& e) {
17304       {
17305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (std::exception& e) {
17308       {
17309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17310       };
17311     } catch (Dali::DaliException e) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17314       };
17315     } catch (...) {
17316       {
17317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17318       };
17319     }
17320   }
17321
17322   jresult = (void *)result;
17323   return jresult;
17324 }
17325
17326
17327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17328   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17329
17330   arg1 = (Dali::Property::Value *)jarg1;
17331   {
17332     try {
17333       delete arg1;
17334     } catch (std::out_of_range& e) {
17335       {
17336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17337       };
17338     } catch (std::exception& e) {
17339       {
17340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17341       };
17342     } catch (Dali::DaliException e) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17345       };
17346     } catch (...) {
17347       {
17348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17349       };
17350     }
17351   }
17352
17353 }
17354
17355
17356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17357   int jresult ;
17358   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17359   Dali::Property::Type result;
17360
17361   arg1 = (Dali::Property::Value *)jarg1;
17362   {
17363     try {
17364       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17365     } catch (std::out_of_range& e) {
17366       {
17367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17368       };
17369     } catch (std::exception& e) {
17370       {
17371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17372       };
17373     } catch (Dali::DaliException e) {
17374       {
17375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17376       };
17377     } catch (...) {
17378       {
17379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17380       };
17381     }
17382   }
17383
17384   jresult = (int)result;
17385   return jresult;
17386 }
17387
17388
17389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17390   unsigned int jresult ;
17391   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17392   bool *arg2 = 0 ;
17393   bool result;
17394
17395   arg1 = (Dali::Property::Value *)jarg1;
17396   arg2 = (bool *)jarg2;
17397   {
17398     try {
17399       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17400     } catch (std::out_of_range& e) {
17401       {
17402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17403       };
17404     } catch (std::exception& e) {
17405       {
17406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17407       };
17408     } catch (Dali::DaliException e) {
17409       {
17410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17411       };
17412     } catch (...) {
17413       {
17414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17415       };
17416     }
17417   }
17418
17419   jresult = result;
17420   return jresult;
17421 }
17422
17423
17424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17425   unsigned int jresult ;
17426   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17427   float *arg2 = 0 ;
17428   bool result;
17429
17430   arg1 = (Dali::Property::Value *)jarg1;
17431   arg2 = (float *)jarg2;
17432   {
17433     try {
17434       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17435     } catch (std::out_of_range& e) {
17436       {
17437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17438       };
17439     } catch (std::exception& e) {
17440       {
17441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17442       };
17443     } catch (Dali::DaliException e) {
17444       {
17445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17446       };
17447     } catch (...) {
17448       {
17449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17450       };
17451     }
17452   }
17453
17454   jresult = result;
17455   return jresult;
17456 }
17457
17458
17459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17460   unsigned int jresult ;
17461   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17462   int *arg2 = 0 ;
17463   bool result;
17464
17465   arg1 = (Dali::Property::Value *)jarg1;
17466   arg2 = (int *)jarg2;
17467   {
17468     try {
17469       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17470     } catch (std::out_of_range& e) {
17471       {
17472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17473       };
17474     } catch (std::exception& e) {
17475       {
17476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17477       };
17478     } catch (Dali::DaliException e) {
17479       {
17480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17481       };
17482     } catch (...) {
17483       {
17484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17485       };
17486     }
17487   }
17488
17489   jresult = result;
17490   return jresult;
17491 }
17492
17493
17494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17495   unsigned int jresult ;
17496   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17497   Dali::Rect< int > *arg2 = 0 ;
17498   bool result;
17499
17500   arg1 = (Dali::Property::Value *)jarg1;
17501   arg2 = (Dali::Rect< int > *)jarg2;
17502   if (!arg2) {
17503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17504     return 0;
17505   }
17506   {
17507     try {
17508       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17509     } catch (std::out_of_range& e) {
17510       {
17511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (std::exception& e) {
17514       {
17515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17516       };
17517     } catch (Dali::DaliException e) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17524       };
17525     }
17526   }
17527
17528   jresult = result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17534   unsigned int jresult ;
17535   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17536   Dali::Vector2 *arg2 = 0 ;
17537   bool result;
17538
17539   arg1 = (Dali::Property::Value *)jarg1;
17540   arg2 = (Dali::Vector2 *)jarg2;
17541   if (!arg2) {
17542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17543     return 0;
17544   }
17545   {
17546     try {
17547       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17548     } catch (std::out_of_range& e) {
17549       {
17550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (std::exception& e) {
17553       {
17554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17555       };
17556     } catch (Dali::DaliException e) {
17557       {
17558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17559       };
17560     } catch (...) {
17561       {
17562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17563       };
17564     }
17565   }
17566
17567   jresult = result;
17568   return jresult;
17569 }
17570
17571
17572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17573   unsigned int jresult ;
17574   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17575   Dali::Vector3 *arg2 = 0 ;
17576   bool result;
17577
17578   arg1 = (Dali::Property::Value *)jarg1;
17579   arg2 = (Dali::Vector3 *)jarg2;
17580   if (!arg2) {
17581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17582     return 0;
17583   }
17584   {
17585     try {
17586       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17587     } catch (std::out_of_range& e) {
17588       {
17589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (std::exception& e) {
17592       {
17593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17594       };
17595     } catch (Dali::DaliException e) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17598       };
17599     } catch (...) {
17600       {
17601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17602       };
17603     }
17604   }
17605
17606   jresult = result;
17607   return jresult;
17608 }
17609
17610
17611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17612   unsigned int jresult ;
17613   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17614   Dali::Vector4 *arg2 = 0 ;
17615   bool result;
17616
17617   arg1 = (Dali::Property::Value *)jarg1;
17618   arg2 = (Dali::Vector4 *)jarg2;
17619   if (!arg2) {
17620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17621     return 0;
17622   }
17623   {
17624     try {
17625       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17626     } catch (std::out_of_range& e) {
17627       {
17628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (std::exception& e) {
17631       {
17632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17633       };
17634     } catch (Dali::DaliException e) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17637       };
17638     } catch (...) {
17639       {
17640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17641       };
17642     }
17643   }
17644
17645   jresult = result;
17646   return jresult;
17647 }
17648
17649
17650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17651   unsigned int jresult ;
17652   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17653   Dali::Matrix3 *arg2 = 0 ;
17654   bool result;
17655
17656   arg1 = (Dali::Property::Value *)jarg1;
17657   arg2 = (Dali::Matrix3 *)jarg2;
17658   if (!arg2) {
17659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17660     return 0;
17661   }
17662   {
17663     try {
17664       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17665     } catch (std::out_of_range& e) {
17666       {
17667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (std::exception& e) {
17670       {
17671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17672       };
17673     } catch (Dali::DaliException e) {
17674       {
17675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17676       };
17677     } catch (...) {
17678       {
17679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17680       };
17681     }
17682   }
17683
17684   jresult = result;
17685   return jresult;
17686 }
17687
17688
17689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17690   unsigned int jresult ;
17691   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17692   Dali::Matrix *arg2 = 0 ;
17693   bool result;
17694
17695   arg1 = (Dali::Property::Value *)jarg1;
17696   arg2 = (Dali::Matrix *)jarg2;
17697   if (!arg2) {
17698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17699     return 0;
17700   }
17701   {
17702     try {
17703       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17704     } catch (std::out_of_range& e) {
17705       {
17706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17707       };
17708     } catch (std::exception& e) {
17709       {
17710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17711       };
17712     } catch (Dali::DaliException e) {
17713       {
17714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17715       };
17716     } catch (...) {
17717       {
17718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17719       };
17720     }
17721   }
17722
17723   jresult = result;
17724   return jresult;
17725 }
17726
17727
17728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17729   unsigned int jresult ;
17730   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17731   Dali::AngleAxis *arg2 = 0 ;
17732   bool result;
17733
17734   arg1 = (Dali::Property::Value *)jarg1;
17735   arg2 = (Dali::AngleAxis *)jarg2;
17736   if (!arg2) {
17737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17738     return 0;
17739   }
17740   {
17741     try {
17742       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17743     } catch (std::out_of_range& e) {
17744       {
17745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (std::exception& e) {
17748       {
17749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17750       };
17751     } catch (Dali::DaliException e) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17754       };
17755     } catch (...) {
17756       {
17757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17758       };
17759     }
17760   }
17761
17762   jresult = result;
17763   return jresult;
17764 }
17765
17766
17767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17768   unsigned int jresult ;
17769   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17770   Dali::Quaternion *arg2 = 0 ;
17771   bool result;
17772
17773   arg1 = (Dali::Property::Value *)jarg1;
17774   arg2 = (Dali::Quaternion *)jarg2;
17775   if (!arg2) {
17776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17777     return 0;
17778   }
17779   {
17780     try {
17781       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17782     } catch (std::out_of_range& e) {
17783       {
17784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17785       };
17786     } catch (std::exception& e) {
17787       {
17788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17789       };
17790     } catch (Dali::DaliException e) {
17791       {
17792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17793       };
17794     } catch (...) {
17795       {
17796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17797       };
17798     }
17799   }
17800
17801   jresult = result;
17802   return jresult;
17803 }
17804
17805
17806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17807   unsigned int jresult ;
17808   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17809   std::string *arg2 = 0 ;
17810   bool result;
17811
17812   arg1 = (Dali::Property::Value *)jarg1;
17813
17814   //typemap in
17815   std::string temp;
17816   arg2 = &temp;
17817
17818   {
17819     try {
17820       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17821     } catch (std::out_of_range& e) {
17822       {
17823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (std::exception& e) {
17826       {
17827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17828       };
17829     } catch (Dali::DaliException e) {
17830       {
17831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17832       };
17833     } catch (...) {
17834       {
17835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17836       };
17837     }
17838   }
17839
17840   jresult = result;
17841
17842   //Typemap argout in c++ file.
17843   //This will convert c++ string to c# string
17844   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17845
17846   return jresult;
17847 }
17848
17849
17850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17851   unsigned int jresult ;
17852   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17853   Dali::Property::Array *arg2 = 0 ;
17854   bool result;
17855
17856   arg1 = (Dali::Property::Value *)jarg1;
17857   arg2 = (Dali::Property::Array *)jarg2;
17858   if (!arg2) {
17859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17860     return 0;
17861   }
17862   {
17863     try {
17864       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17865     } catch (std::out_of_range& e) {
17866       {
17867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17868       };
17869     } catch (std::exception& e) {
17870       {
17871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17872       };
17873     } catch (Dali::DaliException e) {
17874       {
17875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17876       };
17877     } catch (...) {
17878       {
17879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17880       };
17881     }
17882   }
17883
17884   jresult = result;
17885   return jresult;
17886 }
17887
17888
17889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17890   unsigned int jresult ;
17891   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17892   Dali::Property::Map *arg2 = 0 ;
17893   bool result;
17894
17895   arg1 = (Dali::Property::Value *)jarg1;
17896   arg2 = (Dali::Property::Map *)jarg2;
17897   if (!arg2) {
17898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17899     return 0;
17900   }
17901   {
17902     try {
17903       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17904     } catch (std::out_of_range& e) {
17905       {
17906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17907       };
17908     } catch (std::exception& e) {
17909       {
17910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17911       };
17912     } catch (Dali::DaliException e) {
17913       {
17914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17915       };
17916     } catch (...) {
17917       {
17918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17919       };
17920     }
17921   }
17922
17923   jresult = result;
17924   return jresult;
17925 }
17926
17927
17928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17929   unsigned int jresult ;
17930   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17931   Extents *arg2 = 0 ;
17932   bool result;
17933
17934   arg1 = (Dali::Property::Value *)jarg1;
17935   arg2 = (Extents *)jarg2;
17936   if (!arg2) {
17937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17938     return 0;
17939   }
17940   {
17941     try {
17942       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17943     } catch (std::out_of_range& e) {
17944       {
17945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (std::exception& e) {
17948       {
17949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (...) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17954       };
17955     }
17956   }
17957   jresult = result;
17958   return jresult;
17959 }
17960
17961
17962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17963   void * jresult ;
17964   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17965   Dali::Property::Array *result = 0 ;
17966
17967   arg1 = (Dali::Property::Value *)jarg1;
17968   {
17969     try {
17970       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17971     } catch (std::out_of_range& e) {
17972       {
17973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (std::exception& e) {
17976       {
17977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17978       };
17979     } catch (Dali::DaliException e) {
17980       {
17981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17982       };
17983     } catch (...) {
17984       {
17985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17986       };
17987     }
17988   }
17989
17990   jresult = (void *)result;
17991   return jresult;
17992 }
17993
17994
17995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17996   void * jresult ;
17997   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17998   Dali::Property::Map *result = 0 ;
17999
18000   arg1 = (Dali::Property::Value *)jarg1;
18001   {
18002     try {
18003       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18004     } catch (std::out_of_range& e) {
18005       {
18006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18007       };
18008     } catch (std::exception& e) {
18009       {
18010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18011       };
18012     } catch (Dali::DaliException e) {
18013       {
18014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18015       };
18016     } catch (...) {
18017       {
18018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18019       };
18020     }
18021   }
18022
18023   jresult = (void *)result;
18024   return jresult;
18025 }
18026
18027
18028 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18029   char * jresult ;
18030   Dali::Property::Type arg1 ;
18031   char *result = 0 ;
18032
18033   arg1 = (Dali::Property::Type)jarg1;
18034   {
18035     try {
18036       result = (char *)Dali::PropertyTypes::GetName(arg1);
18037     } catch (std::out_of_range& e) {
18038       {
18039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18040       };
18041     } catch (std::exception& e) {
18042       {
18043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18044       };
18045     } catch (Dali::DaliException e) {
18046       {
18047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18048       };
18049     } catch (...) {
18050       {
18051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18052       };
18053     }
18054   }
18055
18056   jresult = SWIG_csharp_string_callback((const char *)result);
18057   return jresult;
18058 }
18059
18060
18061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18062   unsigned int jresult ;
18063   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18064   std::string *arg2 = 0 ;
18065   Dali::Property::Map *arg3 = 0 ;
18066   bool result;
18067
18068   arg1 = (Dali::BaseObject *)jarg1;
18069   if (!jarg2) {
18070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18071     return 0;
18072   }
18073   std::string arg2_str(jarg2);
18074   arg2 = &arg2_str;
18075   arg3 = (Dali::Property::Map *)jarg3;
18076   if (!arg3) {
18077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18078     return 0;
18079   }
18080   {
18081     try {
18082       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18083     } catch (std::out_of_range& e) {
18084       {
18085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18086       };
18087     } catch (std::exception& e) {
18088       {
18089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18090       };
18091     } catch (Dali::DaliException e) {
18092       {
18093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18094       };
18095     } catch (...) {
18096       {
18097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18098       };
18099     }
18100   }
18101
18102   jresult = result;
18103
18104   //argout typemap for const std::string&
18105
18106   return jresult;
18107 }
18108
18109
18110 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18111   char * jresult ;
18112   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18113   std::string *result = 0 ;
18114
18115   arg1 = (Dali::BaseObject *)jarg1;
18116   {
18117     try {
18118       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18119     } catch (std::out_of_range& e) {
18120       {
18121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (std::exception& e) {
18124       {
18125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (Dali::DaliException e) {
18128       {
18129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137
18138   jresult = SWIG_csharp_string_callback(result->c_str());
18139   return jresult;
18140 }
18141
18142
18143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18144   unsigned int jresult ;
18145   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18146   Dali::TypeInfo *arg2 = 0 ;
18147   bool result;
18148
18149   arg1 = (Dali::BaseObject *)jarg1;
18150   arg2 = (Dali::TypeInfo *)jarg2;
18151   if (!arg2) {
18152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18153     return 0;
18154   }
18155   {
18156     try {
18157       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18158     } catch (std::out_of_range& e) {
18159       {
18160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18161       };
18162     } catch (std::exception& e) {
18163       {
18164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18165       };
18166     } catch (Dali::DaliException e) {
18167       {
18168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18169       };
18170     } catch (...) {
18171       {
18172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18173       };
18174     }
18175   }
18176
18177   jresult = result;
18178   return jresult;
18179 }
18180
18181
18182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18183   unsigned int jresult ;
18184   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18185   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18186   std::string *arg3 = 0 ;
18187   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18188   bool result;
18189
18190   arg1 = (Dali::BaseObject *)jarg1;
18191   arg2 = (ConnectionTrackerInterface *)jarg2;
18192   if (!jarg3) {
18193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18194     return 0;
18195   }
18196   std::string arg3_str(jarg3);
18197   arg3 = &arg3_str;
18198   arg4 = (FunctorDelegate *)jarg4;
18199   {
18200     try {
18201       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18202     } catch (std::out_of_range& e) {
18203       {
18204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18205       };
18206     } catch (std::exception& e) {
18207       {
18208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18209       };
18210     } catch (Dali::DaliException e) {
18211       {
18212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18213       };
18214     } catch (...) {
18215       {
18216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18217       };
18218     }
18219   }
18220
18221   jresult = result;
18222
18223   //argout typemap for const std::string&
18224
18225   return jresult;
18226 }
18227
18228
18229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18230   void * jresult ;
18231   Dali::BaseHandle *arg1 = 0 ;
18232   Dali::BaseObject *result = 0 ;
18233
18234   arg1 = (Dali::BaseHandle *)jarg1;
18235   if (!arg1) {
18236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18237     return 0;
18238   }
18239   {
18240     try {
18241       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18242     } catch (std::out_of_range& e) {
18243       {
18244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18245       };
18246     } catch (std::exception& e) {
18247       {
18248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18249       };
18250     } catch (Dali::DaliException e) {
18251       {
18252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18253       };
18254     } catch (...) {
18255       {
18256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18257       };
18258     }
18259   }
18260
18261   jresult = (void *)result;
18262   return jresult;
18263 }
18264
18265
18266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18267   void * jresult ;
18268   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18269   Dali::BaseHandle *result = 0 ;
18270
18271   arg1 = (Dali::BaseObject *)jarg1;
18272   {
18273     try {
18274       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18275     } catch (std::out_of_range& e) {
18276       {
18277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18278       };
18279     } catch (std::exception& e) {
18280       {
18281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18282       };
18283     } catch (Dali::DaliException e) {
18284       {
18285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18286       };
18287     } catch (...) {
18288       {
18289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18290       };
18291     }
18292   }
18293
18294   jresult = (void *)result;
18295   return jresult;
18296 }
18297
18298
18299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18300   void * jresult ;
18301   Dali::BaseHandle *result = 0 ;
18302
18303   {
18304     try {
18305       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18306     } catch (std::out_of_range& e) {
18307       {
18308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18309       };
18310     } catch (std::exception& e) {
18311       {
18312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18313       };
18314     } catch (Dali::DaliException e) {
18315       {
18316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18317       };
18318     } catch (...) {
18319       {
18320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18321       };
18322     }
18323   }
18324
18325   jresult = (void *)result;
18326   return jresult;
18327 }
18328
18329
18330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18331   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18332
18333   arg1 = (Dali::BaseHandle *)jarg1;
18334   {
18335     try {
18336       delete arg1;
18337     } catch (std::out_of_range& e) {
18338       {
18339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18340       };
18341     } catch (std::exception& e) {
18342       {
18343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18344       };
18345     } catch (Dali::DaliException e) {
18346       {
18347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18348       };
18349     } catch (...) {
18350       {
18351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18352       };
18353     }
18354   }
18355
18356 }
18357
18358
18359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18360   void * jresult ;
18361   Dali::BaseHandle *arg1 = 0 ;
18362   Dali::BaseHandle *result = 0 ;
18363
18364   arg1 = (Dali::BaseHandle *)jarg1;
18365   if (!arg1) {
18366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18367     return 0;
18368   }
18369   {
18370     try {
18371       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18372     } catch (std::out_of_range& e) {
18373       {
18374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18375       };
18376     } catch (std::exception& e) {
18377       {
18378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18379       };
18380     } catch (Dali::DaliException e) {
18381       {
18382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18383       };
18384     } catch (...) {
18385       {
18386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18387       };
18388     }
18389   }
18390
18391   jresult = (void *)result;
18392   return jresult;
18393 }
18394
18395
18396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18397   void * jresult ;
18398   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18399   Dali::BaseHandle *arg2 = 0 ;
18400   Dali::BaseHandle *result = 0 ;
18401
18402   arg1 = (Dali::BaseHandle *)jarg1;
18403   arg2 = (Dali::BaseHandle *)jarg2;
18404   if (!arg2) {
18405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18406     return 0;
18407   }
18408   {
18409     try {
18410       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18411     } catch (std::out_of_range& e) {
18412       {
18413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (std::exception& e) {
18416       {
18417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18418       };
18419     } catch (Dali::DaliException e) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18422       };
18423     } catch (...) {
18424       {
18425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18426       };
18427     }
18428   }
18429
18430   jresult = (void *)result;
18431   return jresult;
18432 }
18433
18434
18435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18436   unsigned int jresult ;
18437   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18438   std::string *arg2 = 0 ;
18439   Dali::Property::Map *arg3 = 0 ;
18440   bool result;
18441
18442   arg1 = (Dali::BaseHandle *)jarg1;
18443   if (!jarg2) {
18444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18445     return 0;
18446   }
18447   std::string arg2_str(jarg2);
18448   arg2 = &arg2_str;
18449   arg3 = (Dali::Property::Map *)jarg3;
18450   if (!arg3) {
18451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18452     return 0;
18453   }
18454   {
18455     try {
18456       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18457     } catch (std::out_of_range& e) {
18458       {
18459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18460       };
18461     } catch (std::exception& e) {
18462       {
18463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18464       };
18465     } catch (Dali::DaliException e) {
18466       {
18467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18468       };
18469     } catch (...) {
18470       {
18471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18472       };
18473     }
18474   }
18475
18476   jresult = result;
18477
18478   //argout typemap for const std::string&
18479
18480   return jresult;
18481 }
18482
18483
18484 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18485   char * jresult ;
18486   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18487   std::string *result = 0 ;
18488
18489   arg1 = (Dali::BaseHandle *)jarg1;
18490   {
18491     try {
18492       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18493     } catch (std::out_of_range& e) {
18494       {
18495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (std::exception& e) {
18498       {
18499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18500       };
18501     } catch (Dali::DaliException e) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18504       };
18505     } catch (...) {
18506       {
18507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18508       };
18509     }
18510   }
18511
18512   jresult = SWIG_csharp_string_callback(result->c_str());
18513   return jresult;
18514 }
18515
18516
18517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18518   unsigned int jresult ;
18519   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18520   Dali::TypeInfo *arg2 = 0 ;
18521   bool result;
18522
18523   arg1 = (Dali::BaseHandle *)jarg1;
18524   arg2 = (Dali::TypeInfo *)jarg2;
18525   if (!arg2) {
18526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18527     return 0;
18528   }
18529   {
18530     try {
18531       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18532     } catch (std::out_of_range& e) {
18533       {
18534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (std::exception& e) {
18537       {
18538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18539       };
18540     } catch (Dali::DaliException e) {
18541       {
18542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18543       };
18544     } catch (...) {
18545       {
18546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18547       };
18548     }
18549   }
18550
18551   jresult = result;
18552   return jresult;
18553 }
18554
18555
18556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18557   void * jresult ;
18558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18559   Dali::BaseObject *result = 0 ;
18560
18561   arg1 = (Dali::BaseHandle *)jarg1;
18562   {
18563     try {
18564       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18565     } catch (std::out_of_range& e) {
18566       {
18567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18568       };
18569     } catch (std::exception& e) {
18570       {
18571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18572       };
18573     } catch (Dali::DaliException e) {
18574       {
18575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18576       };
18577     } catch (...) {
18578       {
18579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18580       };
18581     }
18582   }
18583
18584   jresult = (void *)result;
18585   return jresult;
18586 }
18587
18588
18589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18590   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18591
18592   arg1 = (Dali::BaseHandle *)jarg1;
18593   {
18594     try {
18595       (arg1)->Reset();
18596     } catch (std::out_of_range& e) {
18597       {
18598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18599       };
18600     } catch (std::exception& e) {
18601       {
18602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18603       };
18604     } catch (Dali::DaliException e) {
18605       {
18606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18607       };
18608     } catch (...) {
18609       {
18610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18611       };
18612     }
18613   }
18614
18615 }
18616
18617
18618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18619   unsigned int jresult ;
18620   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18621   Dali::BaseHandle *arg2 = 0 ;
18622   bool result;
18623
18624   arg1 = (Dali::BaseHandle *)jarg1;
18625   arg2 = (Dali::BaseHandle *)jarg2;
18626   if (!arg2) {
18627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18628     return 0;
18629   }
18630   {
18631     try {
18632       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18633     } catch (std::out_of_range& e) {
18634       {
18635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18636       };
18637     } catch (std::exception& e) {
18638       {
18639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (Dali::DaliException e) {
18642       {
18643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18644       };
18645     } catch (...) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18648       };
18649     }
18650   }
18651
18652   jresult = result;
18653   return jresult;
18654 }
18655
18656
18657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18658   unsigned int jresult ;
18659   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18660   Dali::BaseHandle *arg2 = 0 ;
18661   bool result;
18662
18663   arg1 = (Dali::BaseHandle *)jarg1;
18664   arg2 = (Dali::BaseHandle *)jarg2;
18665   if (!arg2) {
18666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18667     return 0;
18668   }
18669   {
18670     try {
18671       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18672     } catch (std::out_of_range& e) {
18673       {
18674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (std::exception& e) {
18677       {
18678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18679       };
18680     } catch (Dali::DaliException e) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18683       };
18684     } catch (...) {
18685       {
18686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18687       };
18688     }
18689   }
18690
18691   jresult = result;
18692   return jresult;
18693 }
18694
18695
18696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18697   void * jresult ;
18698   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18699   Dali::RefObject *result = 0 ;
18700
18701   arg1 = (Dali::BaseHandle *)jarg1;
18702   {
18703     try {
18704       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18705     } catch (std::out_of_range& e) {
18706       {
18707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18708       };
18709     } catch (std::exception& e) {
18710       {
18711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18712       };
18713     } catch (Dali::DaliException e) {
18714       {
18715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18716       };
18717     } catch (...) {
18718       {
18719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18720       };
18721     }
18722   }
18723
18724   jresult = (void *)result;
18725   return jresult;
18726 }
18727
18728
18729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18730   unsigned int jresult ;
18731   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18732   bool result;
18733
18734   arg1 = (Dali::BaseHandle *)jarg1;
18735   {
18736     try {
18737       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18738     } catch (std::out_of_range& e) {
18739       {
18740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18741       };
18742     } catch (std::exception& e) {
18743       {
18744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18745       };
18746     } catch (Dali::DaliException e) {
18747       {
18748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18749       };
18750     } catch (...) {
18751       {
18752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18753       };
18754     }
18755   }
18756
18757   jresult = result;
18758   return jresult;
18759 }
18760
18761
18762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18763   unsigned int jresult ;
18764   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18765   Dali::BaseHandle *arg2 = 0 ;
18766   bool result;
18767
18768   arg1 = (Dali::BaseHandle *)jarg1;
18769   arg2 = (Dali::BaseHandle *)jarg2;
18770   if (!arg2) {
18771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18772     return 0;
18773   }
18774   {
18775     try {
18776       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18777     } catch (std::out_of_range& e) {
18778       {
18779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18780       };
18781     } catch (std::exception& e) {
18782       {
18783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18784       };
18785     } catch (Dali::DaliException e) {
18786       {
18787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18788       };
18789     } catch (...) {
18790       {
18791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18792       };
18793     }
18794   }
18795
18796   jresult = result;
18797   return jresult;
18798 }
18799
18800
18801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18802   unsigned int jresult ;
18803   Dali::BaseHandle *arg1 = 0 ;
18804   Dali::BaseHandle *arg2 = 0 ;
18805   bool result;
18806
18807   arg1 = (Dali::BaseHandle *)jarg1;
18808   if (!arg1) {
18809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18810     return 0;
18811   }
18812   arg2 = (Dali::BaseHandle *)jarg2;
18813   if (!arg2) {
18814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18815     return 0;
18816   }
18817   {
18818     try {
18819       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18820     } catch (std::out_of_range& e) {
18821       {
18822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (std::exception& e) {
18825       {
18826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18827       };
18828     } catch (Dali::DaliException e) {
18829       {
18830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18831       };
18832     } catch (...) {
18833       {
18834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18835       };
18836     }
18837   }
18838
18839   jresult = result;
18840   return jresult;
18841 }
18842
18843
18844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18845   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18846
18847   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18848   {
18849     try {
18850       delete arg1;
18851     } catch (std::out_of_range& e) {
18852       {
18853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18854       };
18855     } catch (std::exception& e) {
18856       {
18857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18858       };
18859     } catch (Dali::DaliException e) {
18860       {
18861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18862       };
18863     } catch (...) {
18864       {
18865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18866       };
18867     }
18868   }
18869
18870 }
18871
18872
18873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18874   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18875   SlotObserver *arg2 = (SlotObserver *) 0 ;
18876   CallbackBase *arg3 = (CallbackBase *) 0 ;
18877
18878   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18879   arg2 = (SlotObserver *)jarg2;
18880   arg3 = (CallbackBase *)jarg3;
18881   {
18882     try {
18883       (arg1)->SignalConnected(arg2,arg3);
18884     } catch (std::out_of_range& e) {
18885       {
18886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18887       };
18888     } catch (std::exception& e) {
18889       {
18890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18891       };
18892     } catch (Dali::DaliException e) {
18893       {
18894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18895       };
18896     } catch (...) {
18897       {
18898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18899       };
18900     }
18901   }
18902
18903 }
18904
18905
18906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18907   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18908
18909   arg1 = (Dali::SignalObserver *)jarg1;
18910   {
18911     try {
18912       delete arg1;
18913     } catch (std::out_of_range& e) {
18914       {
18915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18916       };
18917     } catch (std::exception& e) {
18918       {
18919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18920       };
18921     } catch (Dali::DaliException e) {
18922       {
18923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18924       };
18925     } catch (...) {
18926       {
18927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18928       };
18929     }
18930   }
18931
18932 }
18933
18934
18935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18936   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18937   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18938   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18939
18940   arg1 = (Dali::SignalObserver *)jarg1;
18941   arg2 = (Dali::SlotObserver *)jarg2;
18942   arg3 = (Dali::CallbackBase *)jarg3;
18943   {
18944     try {
18945       (arg1)->SignalDisconnected(arg2,arg3);
18946     } catch (std::out_of_range& e) {
18947       {
18948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18949       };
18950     } catch (std::exception& e) {
18951       {
18952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18953       };
18954     } catch (Dali::DaliException e) {
18955       {
18956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18957       };
18958     } catch (...) {
18959       {
18960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18961       };
18962     }
18963   }
18964
18965 }
18966
18967
18968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18969   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18970
18971   arg1 = (Dali::SlotObserver *)jarg1;
18972   {
18973     try {
18974       delete arg1;
18975     } catch (std::out_of_range& e) {
18976       {
18977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18978       };
18979     } catch (std::exception& e) {
18980       {
18981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18982       };
18983     } catch (Dali::DaliException e) {
18984       {
18985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18986       };
18987     } catch (...) {
18988       {
18989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18990       };
18991     }
18992   }
18993
18994 }
18995
18996
18997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18998   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18999   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19000
19001   arg1 = (Dali::SlotObserver *)jarg1;
19002   arg2 = (Dali::CallbackBase *)jarg2;
19003   {
19004     try {
19005       (arg1)->SlotDisconnected(arg2);
19006     } catch (std::out_of_range& e) {
19007       {
19008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19009       };
19010     } catch (std::exception& e) {
19011       {
19012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19013       };
19014     } catch (Dali::DaliException e) {
19015       {
19016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19017       };
19018     } catch (...) {
19019       {
19020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19021       };
19022     }
19023   }
19024
19025 }
19026
19027
19028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19029   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19030
19031   arg1 = (Dali::ConnectionTracker *)jarg1;
19032   {
19033     try {
19034       delete arg1;
19035     } catch (std::out_of_range& e) {
19036       {
19037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19038       };
19039     } catch (std::exception& e) {
19040       {
19041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19042       };
19043     } catch (Dali::DaliException e) {
19044       {
19045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19046       };
19047     } catch (...) {
19048       {
19049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19050       };
19051     }
19052   }
19053
19054 }
19055
19056
19057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19058   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19059
19060   arg1 = (Dali::ConnectionTracker *)jarg1;
19061   {
19062     try {
19063       (arg1)->DisconnectAll();
19064     } catch (std::out_of_range& e) {
19065       {
19066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19067       };
19068     } catch (std::exception& e) {
19069       {
19070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19071       };
19072     } catch (Dali::DaliException e) {
19073       {
19074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19075       };
19076     } catch (...) {
19077       {
19078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19079       };
19080     }
19081   }
19082
19083 }
19084
19085
19086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19087   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19088   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19089   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19090
19091   arg1 = (Dali::ConnectionTracker *)jarg1;
19092   arg2 = (Dali::SlotObserver *)jarg2;
19093   arg3 = (Dali::CallbackBase *)jarg3;
19094   {
19095     try {
19096       (arg1)->SignalConnected(arg2,arg3);
19097     } catch (std::out_of_range& e) {
19098       {
19099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (std::exception& e) {
19102       {
19103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19104       };
19105     } catch (Dali::DaliException e) {
19106       {
19107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19108       };
19109     } catch (...) {
19110       {
19111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19112       };
19113     }
19114   }
19115
19116 }
19117
19118
19119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19120   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19121   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19122   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19123
19124   arg1 = (Dali::ConnectionTracker *)jarg1;
19125   arg2 = (Dali::SlotObserver *)jarg2;
19126   arg3 = (Dali::CallbackBase *)jarg3;
19127   {
19128     try {
19129       (arg1)->SignalDisconnected(arg2,arg3);
19130     } catch (std::out_of_range& e) {
19131       {
19132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19133       };
19134     } catch (std::exception& e) {
19135       {
19136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19137       };
19138     } catch (Dali::DaliException e) {
19139       {
19140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19141       };
19142     } catch (...) {
19143       {
19144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19145       };
19146     }
19147   }
19148
19149 }
19150
19151
19152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19153   unsigned long jresult ;
19154   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19155   std::size_t result;
19156
19157   arg1 = (Dali::ConnectionTracker *)jarg1;
19158   {
19159     try {
19160       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19161     } catch (std::out_of_range& e) {
19162       {
19163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (std::exception& e) {
19166       {
19167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19168       };
19169     } catch (Dali::DaliException e) {
19170       {
19171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19172       };
19173     } catch (...) {
19174       {
19175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19176       };
19177     }
19178   }
19179
19180   jresult = (unsigned long)result;
19181   return jresult;
19182 }
19183
19184
19185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19186   void * jresult ;
19187   Dali::ObjectRegistry *result = 0 ;
19188
19189   {
19190     try {
19191       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19192     } catch (std::out_of_range& e) {
19193       {
19194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (std::exception& e) {
19197       {
19198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19199       };
19200     } catch (Dali::DaliException e) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19203       };
19204     } catch (...) {
19205       {
19206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19207       };
19208     }
19209   }
19210
19211   jresult = (void *)result;
19212   return jresult;
19213 }
19214
19215
19216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19217   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19218
19219   arg1 = (Dali::ObjectRegistry *)jarg1;
19220   {
19221     try {
19222       delete arg1;
19223     } catch (std::out_of_range& e) {
19224       {
19225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19226       };
19227     } catch (std::exception& e) {
19228       {
19229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19230       };
19231     } catch (Dali::DaliException e) {
19232       {
19233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19234       };
19235     } catch (...) {
19236       {
19237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19238       };
19239     }
19240   }
19241
19242 }
19243
19244
19245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19246   void * jresult ;
19247   Dali::ObjectRegistry *arg1 = 0 ;
19248   Dali::ObjectRegistry *result = 0 ;
19249
19250   arg1 = (Dali::ObjectRegistry *)jarg1;
19251   if (!arg1) {
19252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19253     return 0;
19254   }
19255   {
19256     try {
19257       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19258     } catch (std::out_of_range& e) {
19259       {
19260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (std::exception& e) {
19263       {
19264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19265       };
19266     } catch (Dali::DaliException e) {
19267       {
19268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19269       };
19270     } catch (...) {
19271       {
19272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19273       };
19274     }
19275   }
19276
19277   jresult = (void *)result;
19278   return jresult;
19279 }
19280
19281
19282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19283   void * jresult ;
19284   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19285   Dali::ObjectRegistry *arg2 = 0 ;
19286   Dali::ObjectRegistry *result = 0 ;
19287
19288   arg1 = (Dali::ObjectRegistry *)jarg1;
19289   arg2 = (Dali::ObjectRegistry *)jarg2;
19290   if (!arg2) {
19291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19292     return 0;
19293   }
19294   {
19295     try {
19296       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19297     } catch (std::out_of_range& e) {
19298       {
19299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19300       };
19301     } catch (std::exception& e) {
19302       {
19303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19304       };
19305     } catch (Dali::DaliException e) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19308       };
19309     } catch (...) {
19310       {
19311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19312       };
19313     }
19314   }
19315
19316   jresult = (void *)result;
19317   return jresult;
19318 }
19319
19320
19321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19322   void * jresult ;
19323   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19324   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19325
19326   arg1 = (Dali::ObjectRegistry *)jarg1;
19327   {
19328     try {
19329       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19330     } catch (std::out_of_range& e) {
19331       {
19332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19333       };
19334     } catch (std::exception& e) {
19335       {
19336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19337       };
19338     } catch (Dali::DaliException e) {
19339       {
19340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19341       };
19342     } catch (...) {
19343       {
19344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19345       };
19346     }
19347   }
19348
19349   jresult = (void *)result;
19350   return jresult;
19351 }
19352
19353
19354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19355   void * jresult ;
19356   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19357   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19358
19359   arg1 = (Dali::ObjectRegistry *)jarg1;
19360   {
19361     try {
19362       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19363     } catch (std::out_of_range& e) {
19364       {
19365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19366       };
19367     } catch (std::exception& e) {
19368       {
19369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19370       };
19371     } catch (Dali::DaliException e) {
19372       {
19373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19374       };
19375     } catch (...) {
19376       {
19377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19378       };
19379     }
19380   }
19381
19382   jresult = (void *)result;
19383   return jresult;
19384 }
19385
19386
19387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19388   void * jresult ;
19389   Dali::PropertyCondition *result = 0 ;
19390
19391   {
19392     try {
19393       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19394     } catch (std::out_of_range& e) {
19395       {
19396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19397       };
19398     } catch (std::exception& e) {
19399       {
19400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19401       };
19402     } catch (Dali::DaliException e) {
19403       {
19404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19405       };
19406     } catch (...) {
19407       {
19408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19409       };
19410     }
19411   }
19412
19413   jresult = (void *)result;
19414   return jresult;
19415 }
19416
19417
19418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19419   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19420
19421   arg1 = (Dali::PropertyCondition *)jarg1;
19422   {
19423     try {
19424       delete arg1;
19425     } catch (std::out_of_range& e) {
19426       {
19427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19428       };
19429     } catch (std::exception& e) {
19430       {
19431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19432       };
19433     } catch (Dali::DaliException e) {
19434       {
19435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19436       };
19437     } catch (...) {
19438       {
19439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19440       };
19441     }
19442   }
19443
19444 }
19445
19446
19447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19448   void * jresult ;
19449   Dali::PropertyCondition *arg1 = 0 ;
19450   Dali::PropertyCondition *result = 0 ;
19451
19452   arg1 = (Dali::PropertyCondition *)jarg1;
19453   if (!arg1) {
19454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19455     return 0;
19456   }
19457   {
19458     try {
19459       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19460     } catch (std::out_of_range& e) {
19461       {
19462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19463       };
19464     } catch (std::exception& e) {
19465       {
19466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19467       };
19468     } catch (Dali::DaliException e) {
19469       {
19470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19471       };
19472     } catch (...) {
19473       {
19474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19475       };
19476     }
19477   }
19478
19479   jresult = (void *)result;
19480   return jresult;
19481 }
19482
19483
19484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19485   void * jresult ;
19486   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19487   Dali::PropertyCondition *arg2 = 0 ;
19488   Dali::PropertyCondition *result = 0 ;
19489
19490   arg1 = (Dali::PropertyCondition *)jarg1;
19491   arg2 = (Dali::PropertyCondition *)jarg2;
19492   if (!arg2) {
19493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19494     return 0;
19495   }
19496   {
19497     try {
19498       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19499     } catch (std::out_of_range& e) {
19500       {
19501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19502       };
19503     } catch (std::exception& e) {
19504       {
19505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19506       };
19507     } catch (Dali::DaliException e) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19510       };
19511     } catch (...) {
19512       {
19513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19514       };
19515     }
19516   }
19517
19518   jresult = (void *)result;
19519   return jresult;
19520 }
19521
19522
19523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19524   unsigned long jresult ;
19525   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19526   std::size_t result;
19527
19528   arg1 = (Dali::PropertyCondition *)jarg1;
19529   {
19530     try {
19531       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19532     } catch (std::out_of_range& e) {
19533       {
19534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19535       };
19536     } catch (std::exception& e) {
19537       {
19538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19539       };
19540     } catch (...) {
19541       {
19542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19543       };
19544     }
19545   }
19546   jresult = (unsigned long)result;
19547   return jresult;
19548 }
19549
19550
19551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19552   float jresult ;
19553   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19554   std::size_t arg2 ;
19555   float result;
19556
19557   arg1 = (Dali::PropertyCondition *)jarg1;
19558   arg2 = (std::size_t)jarg2;
19559   {
19560     try {
19561       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19562     } catch (std::out_of_range& e) {
19563       {
19564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19565       };
19566     } catch (std::exception& e) {
19567       {
19568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19569       };
19570     } catch (...) {
19571       {
19572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19573       };
19574     }
19575   }
19576   jresult = result;
19577   return jresult;
19578 }
19579
19580
19581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19582   void * jresult ;
19583   float arg1 ;
19584   Dali::PropertyCondition result;
19585
19586   arg1 = (float)jarg1;
19587   {
19588     try {
19589       result = Dali::LessThanCondition(arg1);
19590     } catch (std::out_of_range& e) {
19591       {
19592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (std::exception& e) {
19595       {
19596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19597       };
19598     } catch (Dali::DaliException e) {
19599       {
19600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19601       };
19602     } catch (...) {
19603       {
19604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19605       };
19606     }
19607   }
19608
19609   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19610   return jresult;
19611 }
19612
19613
19614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19615   void * jresult ;
19616   float arg1 ;
19617   Dali::PropertyCondition result;
19618
19619   arg1 = (float)jarg1;
19620   {
19621     try {
19622       result = Dali::GreaterThanCondition(arg1);
19623     } catch (std::out_of_range& e) {
19624       {
19625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19626       };
19627     } catch (std::exception& e) {
19628       {
19629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19630       };
19631     } catch (Dali::DaliException e) {
19632       {
19633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19634       };
19635     } catch (...) {
19636       {
19637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19638       };
19639     }
19640   }
19641
19642   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19643   return jresult;
19644 }
19645
19646
19647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19648   void * jresult ;
19649   float arg1 ;
19650   float arg2 ;
19651   Dali::PropertyCondition result;
19652
19653   arg1 = (float)jarg1;
19654   arg2 = (float)jarg2;
19655   {
19656     try {
19657       result = Dali::InsideCondition(arg1,arg2);
19658     } catch (std::out_of_range& e) {
19659       {
19660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (std::exception& e) {
19663       {
19664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (Dali::DaliException e) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19669       };
19670     } catch (...) {
19671       {
19672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19673       };
19674     }
19675   }
19676
19677   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19678   return jresult;
19679 }
19680
19681
19682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19683   void * jresult ;
19684   float arg1 ;
19685   float arg2 ;
19686   Dali::PropertyCondition result;
19687
19688   arg1 = (float)jarg1;
19689   arg2 = (float)jarg2;
19690   {
19691     try {
19692       result = Dali::OutsideCondition(arg1,arg2);
19693     } catch (std::out_of_range& e) {
19694       {
19695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19696       };
19697     } catch (std::exception& e) {
19698       {
19699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19700       };
19701     } catch (Dali::DaliException e) {
19702       {
19703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19704       };
19705     } catch (...) {
19706       {
19707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19708       };
19709     }
19710   }
19711
19712   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19713   return jresult;
19714 }
19715
19716
19717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19718   void * jresult ;
19719   float arg1 ;
19720   float arg2 ;
19721   Dali::PropertyCondition result;
19722
19723   arg1 = (float)jarg1;
19724   arg2 = (float)jarg2;
19725   {
19726     try {
19727       result = Dali::StepCondition(arg1,arg2);
19728     } catch (std::out_of_range& e) {
19729       {
19730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19731       };
19732     } catch (std::exception& e) {
19733       {
19734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19735       };
19736     } catch (Dali::DaliException e) {
19737       {
19738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19739       };
19740     } catch (...) {
19741       {
19742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19743       };
19744     }
19745   }
19746
19747   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19748   return jresult;
19749 }
19750
19751
19752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19753   void * jresult ;
19754   float arg1 ;
19755   Dali::PropertyCondition result;
19756
19757   arg1 = (float)jarg1;
19758   {
19759     try {
19760       result = Dali::StepCondition(arg1);
19761     } catch (std::out_of_range& e) {
19762       {
19763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19764       };
19765     } catch (std::exception& e) {
19766       {
19767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19768       };
19769     } catch (Dali::DaliException e) {
19770       {
19771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19772       };
19773     } catch (...) {
19774       {
19775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19776       };
19777     }
19778   }
19779
19780   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19781   return jresult;
19782 }
19783
19784
19785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19786   void * jresult ;
19787   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19788   Dali::PropertyCondition result;
19789
19790   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19791   if (!arg1) {
19792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19793     return 0;
19794   }
19795   {
19796     try {
19797       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19798     } catch (std::out_of_range& e) {
19799       {
19800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (std::exception& e) {
19803       {
19804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19805       };
19806     } catch (Dali::DaliException e) {
19807       {
19808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19809       };
19810     } catch (...) {
19811       {
19812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19813       };
19814     }
19815   }
19816
19817   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19818   return jresult;
19819 }
19820
19821
19822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19823   void * jresult ;
19824   Dali::PropertyNotification *result = 0 ;
19825
19826   {
19827     try {
19828       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19829     } catch (std::out_of_range& e) {
19830       {
19831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19832       };
19833     } catch (std::exception& e) {
19834       {
19835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19836       };
19837     } catch (Dali::DaliException e) {
19838       {
19839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19840       };
19841     } catch (...) {
19842       {
19843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19844       };
19845     }
19846   }
19847
19848   jresult = (void *)result;
19849   return jresult;
19850 }
19851
19852
19853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19854   void * jresult ;
19855   Dali::BaseHandle arg1 ;
19856   Dali::BaseHandle *argp1 ;
19857   Dali::PropertyNotification result;
19858
19859   argp1 = (Dali::BaseHandle *)jarg1;
19860   if (!argp1) {
19861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19862     return 0;
19863   }
19864   arg1 = *argp1;
19865   {
19866     try {
19867       result = Dali::PropertyNotification::DownCast(arg1);
19868     } catch (std::out_of_range& e) {
19869       {
19870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19871       };
19872     } catch (std::exception& e) {
19873       {
19874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19875       };
19876     } catch (Dali::DaliException e) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19879       };
19880     } catch (...) {
19881       {
19882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19883       };
19884     }
19885   }
19886
19887   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19888   return jresult;
19889 }
19890
19891
19892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19893   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19894
19895   arg1 = (Dali::PropertyNotification *)jarg1;
19896   {
19897     try {
19898       delete arg1;
19899     } catch (std::out_of_range& e) {
19900       {
19901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19902       };
19903     } catch (std::exception& e) {
19904       {
19905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19906       };
19907     } catch (Dali::DaliException e) {
19908       {
19909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19910       };
19911     } catch (...) {
19912       {
19913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19914       };
19915     }
19916   }
19917
19918 }
19919
19920
19921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19922   void * jresult ;
19923   Dali::PropertyNotification *arg1 = 0 ;
19924   Dali::PropertyNotification *result = 0 ;
19925
19926   arg1 = (Dali::PropertyNotification *)jarg1;
19927   if (!arg1) {
19928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19929     return 0;
19930   }
19931   {
19932     try {
19933       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19934     } catch (std::out_of_range& e) {
19935       {
19936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19937       };
19938     } catch (std::exception& e) {
19939       {
19940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19941       };
19942     } catch (Dali::DaliException e) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19945       };
19946     } catch (...) {
19947       {
19948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19949       };
19950     }
19951   }
19952
19953   jresult = (void *)result;
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19959   void * jresult ;
19960   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19961   Dali::PropertyNotification *arg2 = 0 ;
19962   Dali::PropertyNotification *result = 0 ;
19963
19964   arg1 = (Dali::PropertyNotification *)jarg1;
19965   arg2 = (Dali::PropertyNotification *)jarg2;
19966   if (!arg2) {
19967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19968     return 0;
19969   }
19970   {
19971     try {
19972       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19973     } catch (std::out_of_range& e) {
19974       {
19975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19976       };
19977     } catch (std::exception& e) {
19978       {
19979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19980       };
19981     } catch (Dali::DaliException e) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19984       };
19985     } catch (...) {
19986       {
19987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19988       };
19989     }
19990   }
19991
19992   jresult = (void *)result;
19993   return jresult;
19994 }
19995
19996
19997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19998   void * jresult ;
19999   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20000   Dali::PropertyCondition result;
20001
20002   arg1 = (Dali::PropertyNotification *)jarg1;
20003   {
20004     try {
20005       result = (arg1)->GetCondition();
20006     } catch (std::out_of_range& e) {
20007       {
20008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (std::exception& e) {
20011       {
20012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20013       };
20014     } catch (Dali::DaliException e) {
20015       {
20016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20017       };
20018     } catch (...) {
20019       {
20020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20021       };
20022     }
20023   }
20024
20025   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20031   void * jresult ;
20032   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20033   Dali::Handle result;
20034
20035   arg1 = (Dali::PropertyNotification *)jarg1;
20036   {
20037     try {
20038       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20039     } catch (std::out_of_range& e) {
20040       {
20041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20042       };
20043     } catch (std::exception& e) {
20044       {
20045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20046       };
20047     } catch (Dali::DaliException e) {
20048       {
20049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20050       };
20051     } catch (...) {
20052       {
20053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20054       };
20055     }
20056   }
20057
20058   jresult = new Dali::Handle((const Dali::Handle &)result);
20059   return jresult;
20060 }
20061
20062
20063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20064   int jresult ;
20065   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20066   Dali::Property::Index result;
20067
20068   arg1 = (Dali::PropertyNotification *)jarg1;
20069   {
20070     try {
20071       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20072     } catch (std::out_of_range& e) {
20073       {
20074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20075       };
20076     } catch (std::exception& e) {
20077       {
20078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20079       };
20080     } catch (Dali::DaliException e) {
20081       {
20082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20083       };
20084     } catch (...) {
20085       {
20086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20087       };
20088     }
20089   }
20090
20091   jresult = result;
20092   return jresult;
20093 }
20094
20095
20096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20097   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20098   Dali::PropertyNotification::NotifyMode arg2 ;
20099
20100   arg1 = (Dali::PropertyNotification *)jarg1;
20101   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20102   {
20103     try {
20104       (arg1)->SetNotifyMode(arg2);
20105     } catch (std::out_of_range& e) {
20106       {
20107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20108       };
20109     } catch (std::exception& e) {
20110       {
20111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20112       };
20113     } catch (Dali::DaliException e) {
20114       {
20115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20116       };
20117     } catch (...) {
20118       {
20119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20120       };
20121     }
20122   }
20123
20124 }
20125
20126
20127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20128   int jresult ;
20129   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20130   Dali::PropertyNotification::NotifyMode result;
20131
20132   arg1 = (Dali::PropertyNotification *)jarg1;
20133   {
20134     try {
20135       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20136     } catch (std::out_of_range& e) {
20137       {
20138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20139       };
20140     } catch (std::exception& e) {
20141       {
20142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20143       };
20144     } catch (Dali::DaliException e) {
20145       {
20146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20147       };
20148     } catch (...) {
20149       {
20150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20151       };
20152     }
20153   }
20154
20155   jresult = (int)result;
20156   return jresult;
20157 }
20158
20159
20160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20161   unsigned int jresult ;
20162   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20163   bool result;
20164
20165   arg1 = (Dali::PropertyNotification *)jarg1;
20166   {
20167     try {
20168       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20169     } catch (std::out_of_range& e) {
20170       {
20171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20172       };
20173     } catch (std::exception& e) {
20174       {
20175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20176       };
20177     } catch (Dali::DaliException e) {
20178       {
20179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20180       };
20181     } catch (...) {
20182       {
20183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20184       };
20185     }
20186   }
20187
20188   jresult = result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20194   void * jresult ;
20195   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20196   Dali::PropertyNotifySignalType *result = 0 ;
20197
20198   arg1 = (Dali::PropertyNotification *)jarg1;
20199   {
20200     try {
20201       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20202     } catch (std::out_of_range& e) {
20203       {
20204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20205       };
20206     } catch (std::exception& e) {
20207       {
20208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20209       };
20210     } catch (Dali::DaliException e) {
20211       {
20212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20213       };
20214     } catch (...) {
20215       {
20216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20217       };
20218     }
20219   }
20220
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20227   void * jresult ;
20228   Dali::Handle *result = 0 ;
20229
20230   {
20231     try {
20232       result = (Dali::Handle *)new Dali::Handle();
20233     } catch (std::out_of_range& e) {
20234       {
20235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20236       };
20237     } catch (std::exception& e) {
20238       {
20239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20240       };
20241     } catch (Dali::DaliException e) {
20242       {
20243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20244       };
20245     } catch (...) {
20246       {
20247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20248       };
20249     }
20250   }
20251
20252   jresult = (void *)result;
20253   return jresult;
20254 }
20255
20256
20257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20258   void * jresult ;
20259   Dali::Handle result;
20260
20261   {
20262     try {
20263       result = Dali::Handle::New();
20264     } catch (std::out_of_range& e) {
20265       {
20266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20267       };
20268     } catch (std::exception& e) {
20269       {
20270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20271       };
20272     } catch (Dali::DaliException e) {
20273       {
20274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20275       };
20276     } catch (...) {
20277       {
20278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20279       };
20280     }
20281   }
20282
20283   jresult = new Dali::Handle((const Dali::Handle &)result);
20284   return jresult;
20285 }
20286
20287
20288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20289   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20290
20291   arg1 = (Dali::Handle *)jarg1;
20292   {
20293     try {
20294       delete arg1;
20295     } catch (std::out_of_range& e) {
20296       {
20297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20298       };
20299     } catch (std::exception& e) {
20300       {
20301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20302       };
20303     } catch (Dali::DaliException e) {
20304       {
20305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20306       };
20307     } catch (...) {
20308       {
20309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20310       };
20311     }
20312   }
20313
20314 }
20315
20316
20317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20318   void * jresult ;
20319   Dali::Handle *arg1 = 0 ;
20320   Dali::Handle *result = 0 ;
20321
20322   arg1 = (Dali::Handle *)jarg1;
20323   if (!arg1) {
20324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20325     return 0;
20326   }
20327   {
20328     try {
20329       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20330     } catch (std::out_of_range& e) {
20331       {
20332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20333       };
20334     } catch (std::exception& e) {
20335       {
20336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20337       };
20338     } catch (Dali::DaliException e) {
20339       {
20340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20341       };
20342     } catch (...) {
20343       {
20344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20345       };
20346     }
20347   }
20348
20349   jresult = (void *)result;
20350   return jresult;
20351 }
20352
20353
20354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20355   void * jresult ;
20356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20357   Dali::Handle *arg2 = 0 ;
20358   Dali::Handle *result = 0 ;
20359
20360   arg1 = (Dali::Handle *)jarg1;
20361   arg2 = (Dali::Handle *)jarg2;
20362   if (!arg2) {
20363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20364     return 0;
20365   }
20366   {
20367     try {
20368       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20369     } catch (std::out_of_range& e) {
20370       {
20371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20372       };
20373     } catch (std::exception& e) {
20374       {
20375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20376       };
20377     } catch (Dali::DaliException e) {
20378       {
20379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20380       };
20381     } catch (...) {
20382       {
20383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20384       };
20385     }
20386   }
20387
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20394   void * jresult ;
20395   Dali::BaseHandle arg1 ;
20396   Dali::BaseHandle *argp1 ;
20397   Dali::Handle result;
20398
20399   argp1 = (Dali::BaseHandle *)jarg1;
20400   if (!argp1) {
20401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20402     return 0;
20403   }
20404   arg1 = *argp1;
20405   {
20406     try {
20407       result = Dali::Handle::DownCast(arg1);
20408     } catch (std::out_of_range& e) {
20409       {
20410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20411       };
20412     } catch (std::exception& e) {
20413       {
20414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20415       };
20416     } catch (Dali::DaliException e) {
20417       {
20418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20419       };
20420     } catch (...) {
20421       {
20422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20423       };
20424     }
20425   }
20426
20427   jresult = new Dali::Handle((const Dali::Handle &)result);
20428   return jresult;
20429 }
20430
20431
20432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20433   unsigned int jresult ;
20434   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20435   Dali::Handle::Capability arg2 ;
20436   bool result;
20437
20438   arg1 = (Dali::Handle *)jarg1;
20439   arg2 = (Dali::Handle::Capability)jarg2;
20440   {
20441     try {
20442       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20443     } catch (std::out_of_range& e) {
20444       {
20445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20446       };
20447     } catch (std::exception& e) {
20448       {
20449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20450       };
20451     } catch (Dali::DaliException e) {
20452       {
20453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20454       };
20455     } catch (...) {
20456       {
20457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20458       };
20459     }
20460   }
20461
20462   jresult = result;
20463   return jresult;
20464 }
20465
20466
20467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20468   unsigned int jresult ;
20469   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20470   unsigned int result;
20471
20472   arg1 = (Dali::Handle *)jarg1;
20473   {
20474     try {
20475       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20476     } catch (std::out_of_range& e) {
20477       {
20478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20479       };
20480     } catch (std::exception& e) {
20481       {
20482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20483       };
20484     } catch (Dali::DaliException e) {
20485       {
20486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20487       };
20488     } catch (...) {
20489       {
20490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20491       };
20492     }
20493   }
20494
20495   jresult = result;
20496   return jresult;
20497 }
20498
20499
20500 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20501   char * jresult ;
20502   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20503   Dali::Property::Index arg2 ;
20504   std::string result;
20505
20506   arg1 = (Dali::Handle *)jarg1;
20507   arg2 = (Dali::Property::Index)jarg2;
20508   {
20509     try {
20510       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20511     } catch (std::out_of_range& e) {
20512       {
20513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20514       };
20515     } catch (std::exception& e) {
20516       {
20517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20518       };
20519     } catch (Dali::DaliException e) {
20520       {
20521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20522       };
20523     } catch (...) {
20524       {
20525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20526       };
20527     }
20528   }
20529
20530   jresult = SWIG_csharp_string_callback((&result)->c_str());
20531   return jresult;
20532 }
20533
20534
20535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20536   int jresult ;
20537   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20538   std::string *arg2 = 0 ;
20539   Dali::Property::Index result;
20540
20541   arg1 = (Dali::Handle *)jarg1;
20542   if (!jarg2) {
20543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20544     return 0;
20545   }
20546   std::string arg2_str(jarg2);
20547   arg2 = &arg2_str;
20548   {
20549     try {
20550       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20551     } catch (std::out_of_range& e) {
20552       {
20553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (std::exception& e) {
20556       {
20557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20558       };
20559     } catch (Dali::DaliException e) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20562       };
20563     } catch (...) {
20564       {
20565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20566       };
20567     }
20568   }
20569
20570   jresult = result;
20571
20572   //argout typemap for const std::string&
20573
20574   return jresult;
20575 }
20576
20577
20578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20579   unsigned int jresult ;
20580   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20581   Dali::Property::Index arg2 ;
20582   bool result;
20583
20584   arg1 = (Dali::Handle *)jarg1;
20585   arg2 = (Dali::Property::Index)jarg2;
20586   {
20587     try {
20588       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20589     } catch (std::out_of_range& e) {
20590       {
20591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20592       };
20593     } catch (std::exception& e) {
20594       {
20595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20596       };
20597     } catch (Dali::DaliException e) {
20598       {
20599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20600       };
20601     } catch (...) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20604       };
20605     }
20606   }
20607
20608   jresult = result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20614   unsigned int jresult ;
20615   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20616   Dali::Property::Index arg2 ;
20617   bool result;
20618
20619   arg1 = (Dali::Handle *)jarg1;
20620   arg2 = (Dali::Property::Index)jarg2;
20621   {
20622     try {
20623       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20624     } catch (std::out_of_range& e) {
20625       {
20626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (std::exception& e) {
20629       {
20630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20631       };
20632     } catch (Dali::DaliException e) {
20633       {
20634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20635       };
20636     } catch (...) {
20637       {
20638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20639       };
20640     }
20641   }
20642
20643   jresult = result;
20644   return jresult;
20645 }
20646
20647
20648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20649   unsigned int jresult ;
20650   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20651   Dali::Property::Index arg2 ;
20652   bool result;
20653
20654   arg1 = (Dali::Handle *)jarg1;
20655   arg2 = (Dali::Property::Index)jarg2;
20656   {
20657     try {
20658       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20659     } catch (std::out_of_range& e) {
20660       {
20661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20662       };
20663     } catch (std::exception& e) {
20664       {
20665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20666       };
20667     } catch (Dali::DaliException e) {
20668       {
20669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20670       };
20671     } catch (...) {
20672       {
20673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20674       };
20675     }
20676   }
20677
20678   jresult = result;
20679   return jresult;
20680 }
20681
20682
20683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20684   int jresult ;
20685   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20686   Dali::Property::Index arg2 ;
20687   Dali::Property::Type result;
20688
20689   arg1 = (Dali::Handle *)jarg1;
20690   arg2 = (Dali::Property::Index)jarg2;
20691   {
20692     try {
20693       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20694     } catch (std::out_of_range& e) {
20695       {
20696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (std::exception& e) {
20699       {
20700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (Dali::DaliException e) {
20703       {
20704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712
20713   jresult = (int)result;
20714   return jresult;
20715 }
20716
20717
20718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20719   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20720   Dali::Property::Index arg2 ;
20721   Dali::Property::Value *arg3 = 0 ;
20722
20723   arg1 = (Dali::Handle *)jarg1;
20724   arg2 = (Dali::Property::Index)jarg2;
20725   arg3 = (Dali::Property::Value *)jarg3;
20726   if (!arg3) {
20727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20728     return ;
20729   }
20730   {
20731     try {
20732       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20733     } catch (std::out_of_range& e) {
20734       {
20735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20736       };
20737     } catch (std::exception& e) {
20738       {
20739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20740       };
20741     } catch (Dali::DaliException e) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20744       };
20745     } catch (...) {
20746       {
20747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20748       };
20749     }
20750   }
20751
20752 }
20753
20754
20755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20756   int jresult ;
20757   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20758   std::string *arg2 = 0 ;
20759   Dali::Property::Value *arg3 = 0 ;
20760   Dali::Property::Index result;
20761
20762   arg1 = (Dali::Handle *)jarg1;
20763   if (!jarg2) {
20764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20765     return 0;
20766   }
20767   std::string arg2_str(jarg2);
20768   arg2 = &arg2_str;
20769   arg3 = (Dali::Property::Value *)jarg3;
20770   if (!arg3) {
20771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20772     return 0;
20773   }
20774   {
20775     try {
20776       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20777     } catch (std::out_of_range& e) {
20778       {
20779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20780       };
20781     } catch (std::exception& e) {
20782       {
20783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20784       };
20785     } catch (Dali::DaliException e) {
20786       {
20787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20788       };
20789     } catch (...) {
20790       {
20791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20792       };
20793     }
20794   }
20795
20796   jresult = result;
20797
20798   //argout typemap for const std::string&
20799
20800   return jresult;
20801 }
20802
20803
20804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20805   int jresult ;
20806   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20807   std::string *arg2 = 0 ;
20808   Dali::Property::Value *arg3 = 0 ;
20809   Dali::Property::AccessMode arg4 ;
20810   Dali::Property::Index result;
20811
20812   arg1 = (Dali::Handle *)jarg1;
20813   if (!jarg2) {
20814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20815     return 0;
20816   }
20817   std::string arg2_str(jarg2);
20818   arg2 = &arg2_str;
20819   arg3 = (Dali::Property::Value *)jarg3;
20820   if (!arg3) {
20821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20822     return 0;
20823   }
20824   arg4 = (Dali::Property::AccessMode)jarg4;
20825   {
20826     try {
20827       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20828     } catch (std::out_of_range& e) {
20829       {
20830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20831       };
20832     } catch (std::exception& e) {
20833       {
20834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20835       };
20836     } catch (Dali::DaliException e) {
20837       {
20838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20839       };
20840     } catch (...) {
20841       {
20842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20843       };
20844     }
20845   }
20846
20847   jresult = result;
20848
20849   //argout typemap for const std::string&
20850
20851   return jresult;
20852 }
20853
20854
20855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20856   void * jresult ;
20857   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20858   Dali::Property::Index arg2 ;
20859   Dali::Property::Value result;
20860
20861   arg1 = (Dali::Handle *)jarg1;
20862   arg2 = (Dali::Property::Index)jarg2;
20863   {
20864     try {
20865       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20866     } catch (std::out_of_range& e) {
20867       {
20868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20869       };
20870     } catch (std::exception& e) {
20871       {
20872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20873       };
20874     } catch (Dali::DaliException e) {
20875       {
20876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20877       };
20878     } catch (...) {
20879       {
20880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20881       };
20882     }
20883   }
20884
20885   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20886   return jresult;
20887 }
20888
20889
20890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20891   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20892   Dali::Property::IndexContainer *arg2 = 0 ;
20893
20894   arg1 = (Dali::Handle *)jarg1;
20895   arg2 = (Dali::Property::IndexContainer *)jarg2;
20896   if (!arg2) {
20897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20898     return ;
20899   }
20900   {
20901     try {
20902       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20903     } catch (std::out_of_range& e) {
20904       {
20905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20906       };
20907     } catch (std::exception& e) {
20908       {
20909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20910       };
20911     } catch (Dali::DaliException e) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20914       };
20915     } catch (...) {
20916       {
20917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20918       };
20919     }
20920   }
20921
20922 }
20923
20924
20925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20926   void * jresult ;
20927   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20928   Dali::Property::Index arg2 ;
20929   Dali::PropertyCondition *arg3 = 0 ;
20930   Dali::PropertyNotification result;
20931
20932   arg1 = (Dali::Handle *)jarg1;
20933   arg2 = (Dali::Property::Index)jarg2;
20934   arg3 = (Dali::PropertyCondition *)jarg3;
20935   if (!arg3) {
20936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20937     return 0;
20938   }
20939   {
20940     try {
20941       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20942     } catch (std::out_of_range& e) {
20943       {
20944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20945       };
20946     } catch (std::exception& e) {
20947       {
20948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20949       };
20950     } catch (Dali::DaliException e) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20953       };
20954     } catch (...) {
20955       {
20956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20957       };
20958     }
20959   }
20960
20961   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20962   return jresult;
20963 }
20964
20965
20966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20967   void * jresult ;
20968   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20969   Dali::Property::Index arg2 ;
20970   int arg3 ;
20971   Dali::PropertyCondition *arg4 = 0 ;
20972   Dali::PropertyNotification result;
20973
20974   arg1 = (Dali::Handle *)jarg1;
20975   arg2 = (Dali::Property::Index)jarg2;
20976   arg3 = (int)jarg3;
20977   arg4 = (Dali::PropertyCondition *)jarg4;
20978   if (!arg4) {
20979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20980     return 0;
20981   }
20982   {
20983     try {
20984       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20985     } catch (std::out_of_range& e) {
20986       {
20987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20988       };
20989     } catch (std::exception& e) {
20990       {
20991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20992       };
20993     } catch (Dali::DaliException e) {
20994       {
20995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20996       };
20997     } catch (...) {
20998       {
20999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21000       };
21001     }
21002   }
21003
21004   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21005   return jresult;
21006 }
21007
21008
21009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21010   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21011   Dali::PropertyNotification arg2 ;
21012   Dali::PropertyNotification *argp2 ;
21013
21014   arg1 = (Dali::Handle *)jarg1;
21015   argp2 = (Dali::PropertyNotification *)jarg2;
21016   if (!argp2) {
21017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21018     return ;
21019   }
21020   arg2 = *argp2;
21021   {
21022     try {
21023       (arg1)->RemovePropertyNotification(arg2);
21024     } catch (std::out_of_range& e) {
21025       {
21026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21027       };
21028     } catch (std::exception& e) {
21029       {
21030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21031       };
21032     } catch (Dali::DaliException e) {
21033       {
21034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21035       };
21036     } catch (...) {
21037       {
21038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21039       };
21040     }
21041   }
21042
21043 }
21044
21045
21046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21047   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21048
21049   arg1 = (Dali::Handle *)jarg1;
21050   {
21051     try {
21052       (arg1)->RemovePropertyNotifications();
21053     } catch (std::out_of_range& e) {
21054       {
21055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21056       };
21057     } catch (std::exception& e) {
21058       {
21059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21060       };
21061     } catch (Dali::DaliException e) {
21062       {
21063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21064       };
21065     } catch (...) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21068       };
21069     }
21070   }
21071
21072 }
21073
21074
21075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21077
21078   arg1 = (Dali::Handle *)jarg1;
21079   {
21080     try {
21081       (arg1)->RemoveConstraints();
21082     } catch (std::out_of_range& e) {
21083       {
21084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21085       };
21086     } catch (std::exception& e) {
21087       {
21088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21089       };
21090     } catch (Dali::DaliException e) {
21091       {
21092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21093       };
21094     } catch (...) {
21095       {
21096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21097       };
21098     }
21099   }
21100
21101 }
21102
21103
21104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21105   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21106   unsigned int arg2 ;
21107
21108   arg1 = (Dali::Handle *)jarg1;
21109   arg2 = (unsigned int)jarg2;
21110   {
21111     try {
21112       (arg1)->RemoveConstraints(arg2);
21113     } catch (std::out_of_range& e) {
21114       {
21115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (std::exception& e) {
21118       {
21119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21120       };
21121     } catch (Dali::DaliException e) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21124       };
21125     } catch (...) {
21126       {
21127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21128       };
21129     }
21130   }
21131
21132 }
21133
21134
21135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21136   int jresult ;
21137   Dali::Property::Index result;
21138
21139   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21140   jresult = result;
21141   return jresult;
21142 }
21143
21144
21145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21146   void * jresult ;
21147   Dali::Handle result;
21148
21149   {
21150     try {
21151       result = Dali::WeightObject::New();
21152     } catch (std::out_of_range& e) {
21153       {
21154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21155       };
21156     } catch (std::exception& e) {
21157       {
21158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21159       };
21160     } catch (Dali::DaliException e) {
21161       {
21162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21163       };
21164     } catch (...) {
21165       {
21166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21167       };
21168     }
21169   }
21170
21171   jresult = new Dali::Handle((const Dali::Handle &)result);
21172   return jresult;
21173 }
21174
21175
21176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21177   void * jresult ;
21178   Dali::TypeInfo *result = 0 ;
21179
21180   {
21181     try {
21182       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21183     } catch (std::out_of_range& e) {
21184       {
21185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21186       };
21187     } catch (std::exception& e) {
21188       {
21189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21190       };
21191     } catch (Dali::DaliException e) {
21192       {
21193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21194       };
21195     } catch (...) {
21196       {
21197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21198       };
21199     }
21200   }
21201
21202   jresult = (void *)result;
21203   return jresult;
21204 }
21205
21206
21207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21208   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21209
21210   arg1 = (Dali::TypeInfo *)jarg1;
21211   {
21212     try {
21213       delete arg1;
21214     } catch (std::out_of_range& e) {
21215       {
21216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21217       };
21218     } catch (std::exception& e) {
21219       {
21220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21221       };
21222     } catch (Dali::DaliException e) {
21223       {
21224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21225       };
21226     } catch (...) {
21227       {
21228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21229       };
21230     }
21231   }
21232
21233 }
21234
21235
21236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21237   void * jresult ;
21238   Dali::TypeInfo *arg1 = 0 ;
21239   Dali::TypeInfo *result = 0 ;
21240
21241   arg1 = (Dali::TypeInfo *)jarg1;
21242   if (!arg1) {
21243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21244     return 0;
21245   }
21246   {
21247     try {
21248       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21249     } catch (std::out_of_range& e) {
21250       {
21251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21252       };
21253     } catch (std::exception& e) {
21254       {
21255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21256       };
21257     } catch (Dali::DaliException e) {
21258       {
21259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21260       };
21261     } catch (...) {
21262       {
21263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21264       };
21265     }
21266   }
21267
21268   jresult = (void *)result;
21269   return jresult;
21270 }
21271
21272
21273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21274   void * jresult ;
21275   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21276   Dali::TypeInfo *arg2 = 0 ;
21277   Dali::TypeInfo *result = 0 ;
21278
21279   arg1 = (Dali::TypeInfo *)jarg1;
21280   arg2 = (Dali::TypeInfo *)jarg2;
21281   if (!arg2) {
21282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21283     return 0;
21284   }
21285   {
21286     try {
21287       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21288     } catch (std::out_of_range& e) {
21289       {
21290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21291       };
21292     } catch (std::exception& e) {
21293       {
21294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21295       };
21296     } catch (Dali::DaliException e) {
21297       {
21298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21299       };
21300     } catch (...) {
21301       {
21302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21303       };
21304     }
21305   }
21306
21307   jresult = (void *)result;
21308   return jresult;
21309 }
21310
21311
21312 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21313   char * jresult ;
21314   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21315   std::string *result = 0 ;
21316
21317   arg1 = (Dali::TypeInfo *)jarg1;
21318   {
21319     try {
21320       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21321     } catch (std::out_of_range& e) {
21322       {
21323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (std::exception& e) {
21326       {
21327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21328       };
21329     } catch (Dali::DaliException e) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21332       };
21333     } catch (...) {
21334       {
21335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21336       };
21337     }
21338   }
21339
21340   jresult = SWIG_csharp_string_callback(result->c_str());
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21346   char * jresult ;
21347   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21348   std::string *result = 0 ;
21349
21350   arg1 = (Dali::TypeInfo *)jarg1;
21351   {
21352     try {
21353       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21354     } catch (std::out_of_range& e) {
21355       {
21356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21357       };
21358     } catch (std::exception& e) {
21359       {
21360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21361       };
21362     } catch (Dali::DaliException e) {
21363       {
21364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21365       };
21366     } catch (...) {
21367       {
21368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21369       };
21370     }
21371   }
21372
21373   jresult = SWIG_csharp_string_callback(result->c_str());
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21379   void * jresult ;
21380   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21381   Dali::BaseHandle result;
21382
21383   arg1 = (Dali::TypeInfo *)jarg1;
21384   {
21385     try {
21386       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21387     } catch (std::out_of_range& e) {
21388       {
21389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (std::exception& e) {
21392       {
21393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21394       };
21395     } catch (Dali::DaliException e) {
21396       {
21397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21398       };
21399     } catch (...) {
21400       {
21401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21402       };
21403     }
21404   }
21405
21406   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21407   return jresult;
21408 }
21409
21410
21411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21412   unsigned long jresult ;
21413   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21414   size_t result;
21415
21416   arg1 = (Dali::TypeInfo *)jarg1;
21417   {
21418     try {
21419       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21420     } catch (std::out_of_range& e) {
21421       {
21422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21423       };
21424     } catch (std::exception& e) {
21425       {
21426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21427       };
21428     } catch (Dali::DaliException e) {
21429       {
21430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21431       };
21432     } catch (...) {
21433       {
21434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21435       };
21436     }
21437   }
21438
21439   jresult = (unsigned long)result;
21440   return jresult;
21441 }
21442
21443
21444 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21445   char * jresult ;
21446   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21447   size_t arg2 ;
21448   std::string result;
21449
21450   arg1 = (Dali::TypeInfo *)jarg1;
21451   arg2 = (size_t)jarg2;
21452   {
21453     try {
21454       result = (arg1)->GetActionName(arg2);
21455     } catch (std::out_of_range& e) {
21456       {
21457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21458       };
21459     } catch (std::exception& e) {
21460       {
21461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21462       };
21463     } catch (Dali::DaliException e) {
21464       {
21465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21466       };
21467     } catch (...) {
21468       {
21469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21470       };
21471     }
21472   }
21473
21474   jresult = SWIG_csharp_string_callback((&result)->c_str());
21475   return jresult;
21476 }
21477
21478
21479 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21480   unsigned long jresult ;
21481   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21482   size_t result;
21483
21484   arg1 = (Dali::TypeInfo *)jarg1;
21485   {
21486     try {
21487       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21488     } catch (std::out_of_range& e) {
21489       {
21490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (std::exception& e) {
21493       {
21494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (Dali::DaliException e) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21499       };
21500     } catch (...) {
21501       {
21502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21503       };
21504     }
21505   }
21506
21507   jresult = (unsigned long)result;
21508   return jresult;
21509 }
21510
21511
21512 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21513   char * jresult ;
21514   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21515   size_t arg2 ;
21516   std::string result;
21517
21518   arg1 = (Dali::TypeInfo *)jarg1;
21519   arg2 = (size_t)jarg2;
21520   {
21521     try {
21522       result = (arg1)->GetSignalName(arg2);
21523     } catch (std::out_of_range& e) {
21524       {
21525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21526       };
21527     } catch (std::exception& e) {
21528       {
21529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21530       };
21531     } catch (Dali::DaliException e) {
21532       {
21533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21534       };
21535     } catch (...) {
21536       {
21537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21538       };
21539     }
21540   }
21541
21542   jresult = SWIG_csharp_string_callback((&result)->c_str());
21543   return jresult;
21544 }
21545
21546
21547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21548   unsigned long jresult ;
21549   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21550   size_t result;
21551
21552   arg1 = (Dali::TypeInfo *)jarg1;
21553   {
21554     try {
21555       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21556     } catch (std::out_of_range& e) {
21557       {
21558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (std::exception& e) {
21561       {
21562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21563       };
21564     } catch (Dali::DaliException e) {
21565       {
21566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21567       };
21568     } catch (...) {
21569       {
21570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21571       };
21572     }
21573   }
21574
21575   jresult = (unsigned long)result;
21576   return jresult;
21577 }
21578
21579
21580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21581   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21582   Dali::Property::IndexContainer *arg2 = 0 ;
21583
21584   arg1 = (Dali::TypeInfo *)jarg1;
21585   arg2 = (Dali::Property::IndexContainer *)jarg2;
21586   if (!arg2) {
21587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21588     return ;
21589   }
21590   {
21591     try {
21592       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21593     } catch (std::out_of_range& e) {
21594       {
21595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21596       };
21597     } catch (std::exception& e) {
21598       {
21599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21600       };
21601     } catch (Dali::DaliException e) {
21602       {
21603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21604       };
21605     } catch (...) {
21606       {
21607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21608       };
21609     }
21610   }
21611
21612 }
21613
21614
21615 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21616   char * jresult ;
21617   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21618   Dali::Property::Index arg2 ;
21619   std::string *result = 0 ;
21620
21621   arg1 = (Dali::TypeInfo *)jarg1;
21622   arg2 = (Dali::Property::Index)jarg2;
21623   {
21624     try {
21625       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21626     } catch (std::out_of_range& e) {
21627       {
21628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21629       };
21630     } catch (std::exception& e) {
21631       {
21632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21633       };
21634     } catch (Dali::DaliException e) {
21635       {
21636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21637       };
21638     } catch (...) {
21639       {
21640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21641       };
21642     }
21643   }
21644
21645   jresult = SWIG_csharp_string_callback(result->c_str());
21646   return jresult;
21647 }
21648
21649
21650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21651   void * jresult ;
21652   Dali::TypeRegistry result;
21653
21654   {
21655     try {
21656       result = Dali::TypeRegistry::Get();
21657     } catch (std::out_of_range& e) {
21658       {
21659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21660       };
21661     } catch (std::exception& e) {
21662       {
21663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21664       };
21665     } catch (Dali::DaliException e) {
21666       {
21667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21668       };
21669     } catch (...) {
21670       {
21671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21672       };
21673     }
21674   }
21675
21676   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21677   return jresult;
21678 }
21679
21680
21681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21682   void * jresult ;
21683   Dali::TypeRegistry *result = 0 ;
21684
21685   {
21686     try {
21687       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21688     } catch (std::out_of_range& e) {
21689       {
21690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (std::exception& e) {
21693       {
21694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21695       };
21696     } catch (Dali::DaliException e) {
21697       {
21698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21699       };
21700     } catch (...) {
21701       {
21702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21703       };
21704     }
21705   }
21706
21707   jresult = (void *)result;
21708   return jresult;
21709 }
21710
21711
21712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21713   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21714
21715   arg1 = (Dali::TypeRegistry *)jarg1;
21716   {
21717     try {
21718       delete arg1;
21719     } catch (std::out_of_range& e) {
21720       {
21721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21722       };
21723     } catch (std::exception& e) {
21724       {
21725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21726       };
21727     } catch (Dali::DaliException e) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21730       };
21731     } catch (...) {
21732       {
21733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21734       };
21735     }
21736   }
21737
21738 }
21739
21740
21741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21742   void * jresult ;
21743   Dali::TypeRegistry *arg1 = 0 ;
21744   Dali::TypeRegistry *result = 0 ;
21745
21746   arg1 = (Dali::TypeRegistry *)jarg1;
21747   if (!arg1) {
21748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21749     return 0;
21750   }
21751   {
21752     try {
21753       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21754     } catch (std::out_of_range& e) {
21755       {
21756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21757       };
21758     } catch (std::exception& e) {
21759       {
21760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21761       };
21762     } catch (Dali::DaliException e) {
21763       {
21764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21765       };
21766     } catch (...) {
21767       {
21768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21769       };
21770     }
21771   }
21772
21773   jresult = (void *)result;
21774   return jresult;
21775 }
21776
21777
21778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21779   void * jresult ;
21780   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21781   Dali::TypeRegistry *arg2 = 0 ;
21782   Dali::TypeRegistry *result = 0 ;
21783
21784   arg1 = (Dali::TypeRegistry *)jarg1;
21785   arg2 = (Dali::TypeRegistry *)jarg2;
21786   if (!arg2) {
21787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21788     return 0;
21789   }
21790   {
21791     try {
21792       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21793     } catch (std::out_of_range& e) {
21794       {
21795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21796       };
21797     } catch (std::exception& e) {
21798       {
21799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21800       };
21801     } catch (Dali::DaliException e) {
21802       {
21803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21804       };
21805     } catch (...) {
21806       {
21807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21808       };
21809     }
21810   }
21811
21812   jresult = (void *)result;
21813   return jresult;
21814 }
21815
21816
21817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21818   void * jresult ;
21819   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21820   std::string *arg2 = 0 ;
21821   Dali::TypeInfo result;
21822
21823   arg1 = (Dali::TypeRegistry *)jarg1;
21824   if (!jarg2) {
21825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21826     return 0;
21827   }
21828   std::string arg2_str(jarg2);
21829   arg2 = &arg2_str;
21830   {
21831     try {
21832       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21833     } catch (std::out_of_range& e) {
21834       {
21835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (std::exception& e) {
21838       {
21839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21840       };
21841     } catch (Dali::DaliException e) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21844       };
21845     } catch (...) {
21846       {
21847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21848       };
21849     }
21850   }
21851
21852   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21853
21854   //argout typemap for const std::string&
21855
21856   return jresult;
21857 }
21858
21859
21860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21861   void * jresult ;
21862   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21863   std::type_info *arg2 = 0 ;
21864   Dali::TypeInfo result;
21865
21866   arg1 = (Dali::TypeRegistry *)jarg1;
21867   arg2 = (std::type_info *)jarg2;
21868   if (!arg2) {
21869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21870     return 0;
21871   }
21872   {
21873     try {
21874       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21875     } catch (std::out_of_range& e) {
21876       {
21877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21878       };
21879     } catch (std::exception& e) {
21880       {
21881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21882       };
21883     } catch (Dali::DaliException e) {
21884       {
21885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21886       };
21887     } catch (...) {
21888       {
21889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21890       };
21891     }
21892   }
21893
21894   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21895   return jresult;
21896 }
21897
21898
21899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21900   unsigned long jresult ;
21901   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21902   size_t result;
21903
21904   arg1 = (Dali::TypeRegistry *)jarg1;
21905   {
21906     try {
21907       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21908     } catch (std::out_of_range& e) {
21909       {
21910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21911       };
21912     } catch (std::exception& e) {
21913       {
21914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21915       };
21916     } catch (Dali::DaliException e) {
21917       {
21918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21919       };
21920     } catch (...) {
21921       {
21922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21923       };
21924     }
21925   }
21926
21927   jresult = (unsigned long)result;
21928   return jresult;
21929 }
21930
21931
21932 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21933   char * jresult ;
21934   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21935   size_t arg2 ;
21936   std::string result;
21937
21938   arg1 = (Dali::TypeRegistry *)jarg1;
21939   arg2 = (size_t)jarg2;
21940   {
21941     try {
21942       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21943     } catch (std::out_of_range& e) {
21944       {
21945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21946       };
21947     } catch (std::exception& e) {
21948       {
21949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21950       };
21951     } catch (Dali::DaliException e) {
21952       {
21953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21954       };
21955     } catch (...) {
21956       {
21957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21958       };
21959     }
21960   }
21961
21962   jresult = SWIG_csharp_string_callback((&result)->c_str());
21963   return jresult;
21964 }
21965
21966
21967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21968   void * jresult ;
21969   std::type_info *arg1 = 0 ;
21970   std::type_info *arg2 = 0 ;
21971   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21972   Dali::TypeRegistration *result = 0 ;
21973
21974   arg1 = (std::type_info *)jarg1;
21975   if (!arg1) {
21976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21977     return 0;
21978   }
21979   arg2 = (std::type_info *)jarg2;
21980   if (!arg2) {
21981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21982     return 0;
21983   }
21984   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21985   {
21986     try {
21987       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21988     } catch (std::out_of_range& e) {
21989       {
21990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21991       };
21992     } catch (std::exception& e) {
21993       {
21994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21995       };
21996     } catch (Dali::DaliException e) {
21997       {
21998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21999       };
22000     } catch (...) {
22001       {
22002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22003       };
22004     }
22005   }
22006
22007   jresult = (void *)result;
22008   return jresult;
22009 }
22010
22011
22012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22013   void * jresult ;
22014   std::type_info *arg1 = 0 ;
22015   std::type_info *arg2 = 0 ;
22016   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22017   bool arg4 ;
22018   Dali::TypeRegistration *result = 0 ;
22019
22020   arg1 = (std::type_info *)jarg1;
22021   if (!arg1) {
22022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22023     return 0;
22024   }
22025   arg2 = (std::type_info *)jarg2;
22026   if (!arg2) {
22027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22028     return 0;
22029   }
22030   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22031   arg4 = jarg4 ? true : false;
22032   {
22033     try {
22034       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22035     } catch (std::out_of_range& e) {
22036       {
22037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22038       };
22039     } catch (std::exception& e) {
22040       {
22041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22042       };
22043     } catch (Dali::DaliException e) {
22044       {
22045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22046       };
22047     } catch (...) {
22048       {
22049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22050       };
22051     }
22052   }
22053
22054   jresult = (void *)result;
22055   return jresult;
22056 }
22057
22058
22059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22060   void * jresult ;
22061   std::string *arg1 = 0 ;
22062   std::type_info *arg2 = 0 ;
22063   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22064   Dali::TypeRegistration *result = 0 ;
22065
22066   if (!jarg1) {
22067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22068     return 0;
22069   }
22070   std::string arg1_str(jarg1);
22071   arg1 = &arg1_str;
22072   arg2 = (std::type_info *)jarg2;
22073   if (!arg2) {
22074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22075     return 0;
22076   }
22077   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22078   {
22079     try {
22080       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22081     } catch (std::out_of_range& e) {
22082       {
22083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22084       };
22085     } catch (std::exception& e) {
22086       {
22087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22088       };
22089     } catch (Dali::DaliException e) {
22090       {
22091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22092       };
22093     } catch (...) {
22094       {
22095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22096       };
22097     }
22098   }
22099
22100   jresult = (void *)result;
22101
22102   //argout typemap for const std::string&
22103
22104   return jresult;
22105 }
22106
22107
22108 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22109   char * jresult ;
22110   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22111   std::string result;
22112
22113   arg1 = (Dali::TypeRegistration *)jarg1;
22114   {
22115     try {
22116       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22117     } catch (std::out_of_range& e) {
22118       {
22119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (std::exception& e) {
22122       {
22123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (Dali::DaliException e) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22128       };
22129     } catch (...) {
22130       {
22131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22132       };
22133     }
22134   }
22135
22136   jresult = SWIG_csharp_string_callback((&result)->c_str());
22137   return jresult;
22138 }
22139
22140
22141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22142   std::string *arg1 = 0 ;
22143   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22144
22145   if (!jarg1) {
22146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22147     return ;
22148   }
22149   std::string arg1_str(jarg1);
22150   arg1 = &arg1_str;
22151   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22152   {
22153     try {
22154       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22155     } catch (std::out_of_range& e) {
22156       {
22157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22158       };
22159     } catch (std::exception& e) {
22160       {
22161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22162       };
22163     } catch (Dali::DaliException e) {
22164       {
22165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22166       };
22167     } catch (...) {
22168       {
22169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22170       };
22171     }
22172   }
22173
22174
22175   //argout typemap for const std::string&
22176
22177 }
22178
22179
22180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22181   std::string *arg1 = 0 ;
22182   std::string *arg2 = 0 ;
22183   int arg3 ;
22184   Dali::Property::Type arg4 ;
22185   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22186   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22187
22188   if (!jarg1) {
22189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22190     return ;
22191   }
22192   std::string arg1_str(jarg1);
22193   arg1 = &arg1_str;
22194   if (!jarg2) {
22195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22196     return ;
22197   }
22198   std::string arg2_str(jarg2);
22199   arg2 = &arg2_str;
22200   arg3 = (int)jarg3;
22201   arg4 = (Dali::Property::Type)jarg4;
22202   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22203   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22204   {
22205     try {
22206       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22207     } catch (std::out_of_range& e) {
22208       {
22209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22210       };
22211     } catch (std::exception& e) {
22212       {
22213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22214       };
22215     } catch (Dali::DaliException e) {
22216       {
22217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22218       };
22219     } catch (...) {
22220       {
22221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22222       };
22223     }
22224   }
22225
22226
22227   //argout typemap for const std::string&
22228
22229
22230   //argout typemap for const std::string&
22231
22232 }
22233
22234
22235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22236   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22237
22238   arg1 = (Dali::TypeRegistration *)jarg1;
22239   {
22240     try {
22241       delete arg1;
22242     } catch (std::out_of_range& e) {
22243       {
22244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22245       };
22246     } catch (std::exception& e) {
22247       {
22248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22249       };
22250     } catch (Dali::DaliException e) {
22251       {
22252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22253       };
22254     } catch (...) {
22255       {
22256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22257       };
22258     }
22259   }
22260
22261 }
22262
22263
22264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22265   void * jresult ;
22266   Dali::TypeRegistration *arg1 = 0 ;
22267   std::string *arg2 = 0 ;
22268   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22269   Dali::SignalConnectorType *result = 0 ;
22270
22271   arg1 = (Dali::TypeRegistration *)jarg1;
22272   if (!arg1) {
22273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22274     return 0;
22275   }
22276   if (!jarg2) {
22277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22278     return 0;
22279   }
22280   std::string arg2_str(jarg2);
22281   arg2 = &arg2_str;
22282   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22283   {
22284     try {
22285       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22286     } catch (std::out_of_range& e) {
22287       {
22288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22289       };
22290     } catch (std::exception& e) {
22291       {
22292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22293       };
22294     } catch (Dali::DaliException e) {
22295       {
22296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22297       };
22298     } catch (...) {
22299       {
22300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22301       };
22302     }
22303   }
22304
22305   jresult = (void *)result;
22306
22307   //argout typemap for const std::string&
22308
22309   return jresult;
22310 }
22311
22312
22313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22314   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22315
22316   arg1 = (Dali::SignalConnectorType *)jarg1;
22317   {
22318     try {
22319       delete arg1;
22320     } catch (std::out_of_range& e) {
22321       {
22322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22323       };
22324     } catch (std::exception& e) {
22325       {
22326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22327       };
22328     } catch (Dali::DaliException e) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22331       };
22332     } catch (...) {
22333       {
22334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22335       };
22336     }
22337   }
22338
22339 }
22340
22341
22342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22343   void * jresult ;
22344   Dali::TypeRegistration *arg1 = 0 ;
22345   std::string *arg2 = 0 ;
22346   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22347   Dali::TypeAction *result = 0 ;
22348
22349   arg1 = (Dali::TypeRegistration *)jarg1;
22350   if (!arg1) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22352     return 0;
22353   }
22354   if (!jarg2) {
22355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22356     return 0;
22357   }
22358   std::string arg2_str(jarg2);
22359   arg2 = &arg2_str;
22360   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22361   {
22362     try {
22363       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22364     } catch (std::out_of_range& e) {
22365       {
22366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22367       };
22368     } catch (std::exception& e) {
22369       {
22370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22371       };
22372     } catch (Dali::DaliException e) {
22373       {
22374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22375       };
22376     } catch (...) {
22377       {
22378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22379       };
22380     }
22381   }
22382
22383   jresult = (void *)result;
22384
22385   //argout typemap for const std::string&
22386
22387   return jresult;
22388 }
22389
22390
22391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22392   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22393
22394   arg1 = (Dali::TypeAction *)jarg1;
22395   {
22396     try {
22397       delete arg1;
22398     } catch (std::out_of_range& e) {
22399       {
22400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22401       };
22402     } catch (std::exception& e) {
22403       {
22404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22405       };
22406     } catch (Dali::DaliException e) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22409       };
22410     } catch (...) {
22411       {
22412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22413       };
22414     }
22415   }
22416
22417 }
22418
22419
22420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22421   void * jresult ;
22422   Dali::TypeRegistration *arg1 = 0 ;
22423   std::string *arg2 = 0 ;
22424   Dali::Property::Index arg3 ;
22425   Dali::Property::Type arg4 ;
22426   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22427   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22428   Dali::PropertyRegistration *result = 0 ;
22429
22430   arg1 = (Dali::TypeRegistration *)jarg1;
22431   if (!arg1) {
22432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22433     return 0;
22434   }
22435   if (!jarg2) {
22436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22437     return 0;
22438   }
22439   std::string arg2_str(jarg2);
22440   arg2 = &arg2_str;
22441   arg3 = (Dali::Property::Index)jarg3;
22442   arg4 = (Dali::Property::Type)jarg4;
22443   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22444   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22445   {
22446     try {
22447       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22448     } catch (std::out_of_range& e) {
22449       {
22450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22451       };
22452     } catch (std::exception& e) {
22453       {
22454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22455       };
22456     } catch (Dali::DaliException e) {
22457       {
22458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22459       };
22460     } catch (...) {
22461       {
22462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22463       };
22464     }
22465   }
22466
22467   jresult = (void *)result;
22468
22469   //argout typemap for const std::string&
22470
22471   return jresult;
22472 }
22473
22474
22475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22476   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22477
22478   arg1 = (Dali::PropertyRegistration *)jarg1;
22479   {
22480     try {
22481       delete arg1;
22482     } catch (std::out_of_range& e) {
22483       {
22484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22485       };
22486     } catch (std::exception& e) {
22487       {
22488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22489       };
22490     } catch (Dali::DaliException e) {
22491       {
22492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22493       };
22494     } catch (...) {
22495       {
22496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22497       };
22498     }
22499   }
22500
22501 }
22502
22503
22504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22505   void * jresult ;
22506   Dali::TypeRegistration *arg1 = 0 ;
22507   std::string *arg2 = 0 ;
22508   Dali::Property::Index arg3 ;
22509   Dali::Property::Type arg4 ;
22510   Dali::AnimatablePropertyRegistration *result = 0 ;
22511
22512   arg1 = (Dali::TypeRegistration *)jarg1;
22513   if (!arg1) {
22514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22515     return 0;
22516   }
22517   if (!jarg2) {
22518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22519     return 0;
22520   }
22521   std::string arg2_str(jarg2);
22522   arg2 = &arg2_str;
22523   arg3 = (Dali::Property::Index)jarg3;
22524   arg4 = (Dali::Property::Type)jarg4;
22525   {
22526     try {
22527       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22528     } catch (std::out_of_range& e) {
22529       {
22530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22531       };
22532     } catch (std::exception& e) {
22533       {
22534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22535       };
22536     } catch (Dali::DaliException e) {
22537       {
22538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22539       };
22540     } catch (...) {
22541       {
22542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22543       };
22544     }
22545   }
22546
22547   jresult = (void *)result;
22548
22549   //argout typemap for const std::string&
22550
22551   return jresult;
22552 }
22553
22554
22555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22556   void * jresult ;
22557   Dali::TypeRegistration *arg1 = 0 ;
22558   std::string *arg2 = 0 ;
22559   Dali::Property::Index arg3 ;
22560   Dali::Property::Value *arg4 = 0 ;
22561   Dali::AnimatablePropertyRegistration *result = 0 ;
22562
22563   arg1 = (Dali::TypeRegistration *)jarg1;
22564   if (!arg1) {
22565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22566     return 0;
22567   }
22568   if (!jarg2) {
22569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22570     return 0;
22571   }
22572   std::string arg2_str(jarg2);
22573   arg2 = &arg2_str;
22574   arg3 = (Dali::Property::Index)jarg3;
22575   arg4 = (Dali::Property::Value *)jarg4;
22576   if (!arg4) {
22577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22578     return 0;
22579   }
22580   {
22581     try {
22582       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22583     } catch (std::out_of_range& e) {
22584       {
22585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (std::exception& e) {
22588       {
22589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22590       };
22591     } catch (Dali::DaliException e) {
22592       {
22593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22594       };
22595     } catch (...) {
22596       {
22597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22598       };
22599     }
22600   }
22601
22602   jresult = (void *)result;
22603
22604   //argout typemap for const std::string&
22605
22606   return jresult;
22607 }
22608
22609
22610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22611   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22612
22613   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22614   {
22615     try {
22616       delete arg1;
22617     } catch (std::out_of_range& e) {
22618       {
22619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22620       };
22621     } catch (std::exception& e) {
22622       {
22623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22624       };
22625     } catch (Dali::DaliException e) {
22626       {
22627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22628       };
22629     } catch (...) {
22630       {
22631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22632       };
22633     }
22634   }
22635
22636 }
22637
22638
22639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22640   void * jresult ;
22641   Dali::TypeRegistration *arg1 = 0 ;
22642   std::string *arg2 = 0 ;
22643   Dali::Property::Index arg3 ;
22644   Dali::Property::Index arg4 ;
22645   unsigned int arg5 ;
22646   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22647
22648   arg1 = (Dali::TypeRegistration *)jarg1;
22649   if (!arg1) {
22650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22651     return 0;
22652   }
22653   if (!jarg2) {
22654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22655     return 0;
22656   }
22657   std::string arg2_str(jarg2);
22658   arg2 = &arg2_str;
22659   arg3 = (Dali::Property::Index)jarg3;
22660   arg4 = (Dali::Property::Index)jarg4;
22661   arg5 = (unsigned int)jarg5;
22662   {
22663     try {
22664       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22665     } catch (std::out_of_range& e) {
22666       {
22667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (std::exception& e) {
22670       {
22671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22672       };
22673     } catch (Dali::DaliException e) {
22674       {
22675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22676       };
22677     } catch (...) {
22678       {
22679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22680       };
22681     }
22682   }
22683
22684   jresult = (void *)result;
22685
22686   //argout typemap for const std::string&
22687
22688   return jresult;
22689 }
22690
22691
22692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22693   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22694
22695   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22696   {
22697     try {
22698       delete arg1;
22699     } catch (std::out_of_range& e) {
22700       {
22701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22702       };
22703     } catch (std::exception& e) {
22704       {
22705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22706       };
22707     } catch (Dali::DaliException e) {
22708       {
22709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22710       };
22711     } catch (...) {
22712       {
22713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22714       };
22715     }
22716   }
22717
22718 }
22719
22720
22721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22722   void * jresult ;
22723   Dali::TypeRegistration *arg1 = 0 ;
22724   std::string *arg2 = 0 ;
22725   Dali::Property::Index arg3 ;
22726   Dali::Property::Type arg4 ;
22727   Dali::ChildPropertyRegistration *result = 0 ;
22728
22729   arg1 = (Dali::TypeRegistration *)jarg1;
22730   if (!arg1) {
22731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22732     return 0;
22733   }
22734   if (!jarg2) {
22735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22736     return 0;
22737   }
22738   std::string arg2_str(jarg2);
22739   arg2 = &arg2_str;
22740   arg3 = (Dali::Property::Index)jarg3;
22741   arg4 = (Dali::Property::Type)jarg4;
22742   {
22743     try {
22744       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22745     } catch (std::out_of_range& e) {
22746       {
22747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22748       };
22749     } catch (std::exception& e) {
22750       {
22751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22752       };
22753     } catch (Dali::DaliException e) {
22754       {
22755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22756       };
22757     } catch (...) {
22758       {
22759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22760       };
22761     }
22762   }
22763
22764   jresult = (void *)result;
22765
22766   //argout typemap for const std::string&
22767
22768   return jresult;
22769 }
22770
22771
22772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22773   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22774
22775   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22776   {
22777     try {
22778       delete arg1;
22779     } catch (std::out_of_range& e) {
22780       {
22781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22782       };
22783     } catch (std::exception& e) {
22784       {
22785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22786       };
22787     } catch (Dali::DaliException e) {
22788       {
22789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22790       };
22791     } catch (...) {
22792       {
22793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22794       };
22795     }
22796   }
22797
22798 }
22799
22800
22801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22802   unsigned int jresult ;
22803   std::string *arg1 = 0 ;
22804   std::type_info *arg2 = 0 ;
22805   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22806   bool result;
22807
22808   if (!jarg1) {
22809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22810     return 0;
22811   }
22812   std::string arg1_str(jarg1);
22813   arg1 = &arg1_str;
22814   arg2 = (std::type_info *)jarg2;
22815   if (!arg2) {
22816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22817     return 0;
22818   }
22819   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22820   {
22821     try {
22822       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22823     } catch (std::out_of_range& e) {
22824       {
22825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22826       };
22827     } catch (std::exception& e) {
22828       {
22829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22830       };
22831     } catch (Dali::DaliException e) {
22832       {
22833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22834       };
22835     } catch (...) {
22836       {
22837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22838       };
22839     }
22840   }
22841
22842   jresult = result;
22843
22844   //argout typemap for const std::string&
22845
22846   return jresult;
22847 }
22848
22849
22850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22851   unsigned int jresult ;
22852   std::string *arg1 = 0 ;
22853   std::string *arg2 = 0 ;
22854   Dali::Property::Index arg3 ;
22855   Dali::Property::Type arg4 ;
22856   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22857   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22858   bool result;
22859
22860   if (!jarg1) {
22861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22862     return 0;
22863   }
22864   std::string arg1_str(jarg1);
22865   arg1 = &arg1_str;
22866   if (!jarg2) {
22867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22868     return 0;
22869   }
22870   std::string arg2_str(jarg2);
22871   arg2 = &arg2_str;
22872   arg3 = (Dali::Property::Index)jarg3;
22873   arg4 = (Dali::Property::Type)jarg4;
22874   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22875   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22876   {
22877     try {
22878       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22879     } catch (std::out_of_range& e) {
22880       {
22881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22882       };
22883     } catch (std::exception& e) {
22884       {
22885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22886       };
22887     } catch (Dali::DaliException e) {
22888       {
22889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22890       };
22891     } catch (...) {
22892       {
22893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22894       };
22895     }
22896   }
22897
22898   jresult = result;
22899
22900   //argout typemap for const std::string&
22901
22902
22903   //argout typemap for const std::string&
22904
22905   return jresult;
22906 }
22907
22908
22909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22910   float jresult ;
22911   float result;
22912
22913   result = (float)(float)Dali::ParentOrigin::TOP;
22914   jresult = result;
22915   return jresult;
22916 }
22917
22918
22919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22920   float jresult ;
22921   float result;
22922
22923   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22924   jresult = result;
22925   return jresult;
22926 }
22927
22928
22929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22930   float jresult ;
22931   float result;
22932
22933   result = (float)(float)Dali::ParentOrigin::LEFT;
22934   jresult = result;
22935   return jresult;
22936 }
22937
22938
22939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22940   float jresult ;
22941   float result;
22942
22943   result = (float)(float)Dali::ParentOrigin::RIGHT;
22944   jresult = result;
22945   return jresult;
22946 }
22947
22948
22949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22950   float jresult ;
22951   float result;
22952
22953   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22954   jresult = result;
22955   return jresult;
22956 }
22957
22958
22959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22960   void * jresult ;
22961   Dali::Vector3 *result = 0 ;
22962
22963   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22964   jresult = (void *)result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22970   void * jresult ;
22971   Dali::Vector3 *result = 0 ;
22972
22973   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22974   jresult = (void *)result;
22975   return jresult;
22976 }
22977
22978
22979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22980   void * jresult ;
22981   Dali::Vector3 *result = 0 ;
22982
22983   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22984   jresult = (void *)result;
22985   return jresult;
22986 }
22987
22988
22989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22990   void * jresult ;
22991   Dali::Vector3 *result = 0 ;
22992
22993   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22994   jresult = (void *)result;
22995   return jresult;
22996 }
22997
22998
22999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23000   void * jresult ;
23001   Dali::Vector3 *result = 0 ;
23002
23003   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23004   jresult = (void *)result;
23005   return jresult;
23006 }
23007
23008
23009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23010   void * jresult ;
23011   Dali::Vector3 *result = 0 ;
23012
23013   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23014   jresult = (void *)result;
23015   return jresult;
23016 }
23017
23018
23019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23020   void * jresult ;
23021   Dali::Vector3 *result = 0 ;
23022
23023   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23030   void * jresult ;
23031   Dali::Vector3 *result = 0 ;
23032
23033   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23034   jresult = (void *)result;
23035   return jresult;
23036 }
23037
23038
23039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23040   void * jresult ;
23041   Dali::Vector3 *result = 0 ;
23042
23043   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23044   jresult = (void *)result;
23045   return jresult;
23046 }
23047
23048
23049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23050   float jresult ;
23051   float result;
23052
23053   result = (float)(float)Dali::AnchorPoint::TOP;
23054   jresult = result;
23055   return jresult;
23056 }
23057
23058
23059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23060   float jresult ;
23061   float result;
23062
23063   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23064   jresult = result;
23065   return jresult;
23066 }
23067
23068
23069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23070   float jresult ;
23071   float result;
23072
23073   result = (float)(float)Dali::AnchorPoint::LEFT;
23074   jresult = result;
23075   return jresult;
23076 }
23077
23078
23079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23080   float jresult ;
23081   float result;
23082
23083   result = (float)(float)Dali::AnchorPoint::RIGHT;
23084   jresult = result;
23085   return jresult;
23086 }
23087
23088
23089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23090   float jresult ;
23091   float result;
23092
23093   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23094   jresult = result;
23095   return jresult;
23096 }
23097
23098
23099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23100   void * jresult ;
23101   Dali::Vector3 *result = 0 ;
23102
23103   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23104   jresult = (void *)result;
23105   return jresult;
23106 }
23107
23108
23109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23110   void * jresult ;
23111   Dali::Vector3 *result = 0 ;
23112
23113   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23114   jresult = (void *)result;
23115   return jresult;
23116 }
23117
23118
23119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23120   void * jresult ;
23121   Dali::Vector3 *result = 0 ;
23122
23123   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23124   jresult = (void *)result;
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23130   void * jresult ;
23131   Dali::Vector3 *result = 0 ;
23132
23133   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23134   jresult = (void *)result;
23135   return jresult;
23136 }
23137
23138
23139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23140   void * jresult ;
23141   Dali::Vector3 *result = 0 ;
23142
23143   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23144   jresult = (void *)result;
23145   return jresult;
23146 }
23147
23148
23149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23150   void * jresult ;
23151   Dali::Vector3 *result = 0 ;
23152
23153   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23154   jresult = (void *)result;
23155   return jresult;
23156 }
23157
23158
23159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23160   void * jresult ;
23161   Dali::Vector3 *result = 0 ;
23162
23163   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23164   jresult = (void *)result;
23165   return jresult;
23166 }
23167
23168
23169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23170   void * jresult ;
23171   Dali::Vector3 *result = 0 ;
23172
23173   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23174   jresult = (void *)result;
23175   return jresult;
23176 }
23177
23178
23179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23180   void * jresult ;
23181   Dali::Vector3 *result = 0 ;
23182
23183   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23184   jresult = (void *)result;
23185   return jresult;
23186 }
23187
23188
23189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23190   void * jresult ;
23191   Dali::Vector4 *result = 0 ;
23192
23193   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23194   jresult = (void *)result;
23195   return jresult;
23196 }
23197
23198
23199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23200   void * jresult ;
23201   Dali::Vector4 *result = 0 ;
23202
23203   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23204   jresult = (void *)result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23210   void * jresult ;
23211   Dali::Vector4 *result = 0 ;
23212
23213   result = (Dali::Vector4 *)&Dali::Color::RED;
23214   jresult = (void *)result;
23215   return jresult;
23216 }
23217
23218
23219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23220   void * jresult ;
23221   Dali::Vector4 *result = 0 ;
23222
23223   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23224   jresult = (void *)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23230   void * jresult ;
23231   Dali::Vector4 *result = 0 ;
23232
23233   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23234   jresult = (void *)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23240   void * jresult ;
23241   Dali::Vector4 *result = 0 ;
23242
23243   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23244   jresult = (void *)result;
23245   return jresult;
23246 }
23247
23248
23249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23250   void * jresult ;
23251   Dali::Vector4 *result = 0 ;
23252
23253   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23254   jresult = (void *)result;
23255   return jresult;
23256 }
23257
23258
23259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23260   void * jresult ;
23261   Dali::Vector4 *result = 0 ;
23262
23263   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23264   jresult = (void *)result;
23265   return jresult;
23266 }
23267
23268
23269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23270   void * jresult ;
23271   Dali::Vector4 *result = 0 ;
23272
23273   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23274   jresult = (void *)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23280   float jresult ;
23281   float result;
23282
23283   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23284   jresult = result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23290   float jresult ;
23291   float result;
23292
23293   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23294   jresult = result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23300   float jresult ;
23301   float result;
23302
23303   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23304   jresult = result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23310   float jresult ;
23311   float result;
23312
23313   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23314   jresult = result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23320   float jresult ;
23321   float result;
23322
23323   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23324   jresult = result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23330   float jresult ;
23331   float result;
23332
23333   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23334   jresult = result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23340   float jresult ;
23341   float result;
23342
23343   result = (float)(float)Dali::Math::PI;
23344   jresult = result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23350   float jresult ;
23351   float result;
23352
23353   result = (float)(float)Dali::Math::PI_2;
23354   jresult = result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23360   float jresult ;
23361   float result;
23362
23363   result = (float)(float)Dali::Math::PI_4;
23364   jresult = result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23370   float jresult ;
23371   float result;
23372
23373   result = (float)(float)Dali::Math::PI_OVER_180;
23374   jresult = result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23380   float jresult ;
23381   float result;
23382
23383   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23384   jresult = result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23390   int jresult ;
23391   Dali::ResizePolicy::Type result;
23392
23393   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23400   unsigned long jresult ;
23401   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23402   Dali::VectorBase::SizeType result;
23403
23404   arg1 = (Dali::VectorBase *)jarg1;
23405   {
23406     try {
23407       result = ((Dali::VectorBase const *)arg1)->Count();
23408     } catch (std::out_of_range& e) {
23409       {
23410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23411       };
23412     } catch (std::exception& e) {
23413       {
23414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23415       };
23416     } catch (Dali::DaliException e) {
23417       {
23418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23419       };
23420     } catch (...) {
23421       {
23422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23423       };
23424     }
23425   }
23426
23427   jresult = (unsigned long)result;
23428   return jresult;
23429 }
23430
23431
23432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23433   unsigned long jresult ;
23434   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23435   Dali::VectorBase::SizeType result;
23436
23437   arg1 = (Dali::VectorBase *)jarg1;
23438   {
23439     try {
23440       result = ((Dali::VectorBase const *)arg1)->Size();
23441     } catch (std::out_of_range& e) {
23442       {
23443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23444       };
23445     } catch (std::exception& e) {
23446       {
23447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23448       };
23449     } catch (Dali::DaliException e) {
23450       {
23451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23452       };
23453     } catch (...) {
23454       {
23455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23456       };
23457     }
23458   }
23459
23460   jresult = (unsigned long)result;
23461   return jresult;
23462 }
23463
23464
23465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23466   unsigned int jresult ;
23467   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23468   bool result;
23469
23470   arg1 = (Dali::VectorBase *)jarg1;
23471   {
23472     try {
23473       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23474     } catch (std::out_of_range& e) {
23475       {
23476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23477       };
23478     } catch (std::exception& e) {
23479       {
23480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23481       };
23482     } catch (Dali::DaliException e) {
23483       {
23484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23485       };
23486     } catch (...) {
23487       {
23488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23489       };
23490     }
23491   }
23492
23493   jresult = result;
23494   return jresult;
23495 }
23496
23497
23498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23499   unsigned long jresult ;
23500   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23501   Dali::VectorBase::SizeType result;
23502
23503   arg1 = (Dali::VectorBase *)jarg1;
23504   {
23505     try {
23506       result = ((Dali::VectorBase const *)arg1)->Capacity();
23507     } catch (std::out_of_range& e) {
23508       {
23509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23510       };
23511     } catch (std::exception& e) {
23512       {
23513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23514       };
23515     } catch (Dali::DaliException e) {
23516       {
23517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23518       };
23519     } catch (...) {
23520       {
23521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23522       };
23523     }
23524   }
23525
23526   jresult = (unsigned long)result;
23527   return jresult;
23528 }
23529
23530
23531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23532   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23533
23534   arg1 = (Dali::VectorBase *)jarg1;
23535   {
23536     try {
23537       (arg1)->Release();
23538     } catch (std::out_of_range& e) {
23539       {
23540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23541       };
23542     } catch (std::exception& e) {
23543       {
23544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23545       };
23546     } catch (Dali::DaliException e) {
23547       {
23548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23549       };
23550     } catch (...) {
23551       {
23552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23553       };
23554     }
23555   }
23556
23557 }
23558
23559
23560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23561   void * jresult ;
23562   Dali::Image *result = 0 ;
23563
23564   {
23565     try {
23566       result = (Dali::Image *)new Dali::Image();
23567     } catch (std::out_of_range& e) {
23568       {
23569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23570       };
23571     } catch (std::exception& e) {
23572       {
23573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23574       };
23575     } catch (Dali::DaliException e) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23578       };
23579     } catch (...) {
23580       {
23581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23582       };
23583     }
23584   }
23585
23586   jresult = (void *)result;
23587   return jresult;
23588 }
23589
23590
23591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23592   Dali::Image *arg1 = (Dali::Image *) 0 ;
23593
23594   arg1 = (Dali::Image *)jarg1;
23595   {
23596     try {
23597       delete arg1;
23598     } catch (std::out_of_range& e) {
23599       {
23600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23601       };
23602     } catch (std::exception& e) {
23603       {
23604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23605       };
23606     } catch (Dali::DaliException e) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23609       };
23610     } catch (...) {
23611       {
23612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23613       };
23614     }
23615   }
23616
23617 }
23618
23619
23620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23621   void * jresult ;
23622   Dali::Image *arg1 = 0 ;
23623   Dali::Image *result = 0 ;
23624
23625   arg1 = (Dali::Image *)jarg1;
23626   if (!arg1) {
23627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23628     return 0;
23629   }
23630   {
23631     try {
23632       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23633     } catch (std::out_of_range& e) {
23634       {
23635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23636       };
23637     } catch (std::exception& e) {
23638       {
23639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23640       };
23641     } catch (Dali::DaliException e) {
23642       {
23643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23644       };
23645     } catch (...) {
23646       {
23647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23648       };
23649     }
23650   }
23651
23652   jresult = (void *)result;
23653   return jresult;
23654 }
23655
23656
23657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23658   void * jresult ;
23659   Dali::Image *arg1 = (Dali::Image *) 0 ;
23660   Dali::Image *arg2 = 0 ;
23661   Dali::Image *result = 0 ;
23662
23663   arg1 = (Dali::Image *)jarg1;
23664   arg2 = (Dali::Image *)jarg2;
23665   if (!arg2) {
23666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23667     return 0;
23668   }
23669   {
23670     try {
23671       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23672     } catch (std::out_of_range& e) {
23673       {
23674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23675       };
23676     } catch (std::exception& e) {
23677       {
23678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23679       };
23680     } catch (Dali::DaliException e) {
23681       {
23682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23683       };
23684     } catch (...) {
23685       {
23686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23687       };
23688     }
23689   }
23690
23691   jresult = (void *)result;
23692   return jresult;
23693 }
23694
23695
23696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23697   void * jresult ;
23698   Dali::BaseHandle arg1 ;
23699   Dali::BaseHandle *argp1 ;
23700   Dali::Image result;
23701
23702   argp1 = (Dali::BaseHandle *)jarg1;
23703   if (!argp1) {
23704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23705     return 0;
23706   }
23707   arg1 = *argp1;
23708   {
23709     try {
23710       result = Dali::Image::DownCast(arg1);
23711     } catch (std::out_of_range& e) {
23712       {
23713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23714       };
23715     } catch (std::exception& e) {
23716       {
23717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23718       };
23719     } catch (Dali::DaliException e) {
23720       {
23721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23722       };
23723     } catch (...) {
23724       {
23725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23726       };
23727     }
23728   }
23729
23730   jresult = new Dali::Image((const Dali::Image &)result);
23731   return jresult;
23732 }
23733
23734
23735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23736   unsigned int jresult ;
23737   Dali::Image *arg1 = (Dali::Image *) 0 ;
23738   unsigned int result;
23739
23740   arg1 = (Dali::Image *)jarg1;
23741   {
23742     try {
23743       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23744     } catch (std::out_of_range& e) {
23745       {
23746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (std::exception& e) {
23749       {
23750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (Dali::DaliException e) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762
23763   jresult = result;
23764   return jresult;
23765 }
23766
23767
23768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23769   unsigned int jresult ;
23770   Dali::Image *arg1 = (Dali::Image *) 0 ;
23771   unsigned int result;
23772
23773   arg1 = (Dali::Image *)jarg1;
23774   {
23775     try {
23776       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23777     } catch (std::out_of_range& e) {
23778       {
23779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23780       };
23781     } catch (std::exception& e) {
23782       {
23783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23784       };
23785     } catch (Dali::DaliException e) {
23786       {
23787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23788       };
23789     } catch (...) {
23790       {
23791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23792       };
23793     }
23794   }
23795
23796   jresult = result;
23797   return jresult;
23798 }
23799
23800
23801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23802   void * jresult ;
23803   Dali::Image *arg1 = (Dali::Image *) 0 ;
23804   Dali::Image::ImageSignalType *result = 0 ;
23805
23806   arg1 = (Dali::Image *)jarg1;
23807   {
23808     try {
23809       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23810     } catch (std::out_of_range& e) {
23811       {
23812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23813       };
23814     } catch (std::exception& e) {
23815       {
23816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23817       };
23818     } catch (Dali::DaliException e) {
23819       {
23820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23821       };
23822     } catch (...) {
23823       {
23824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23825       };
23826     }
23827   }
23828
23829   jresult = (void *)result;
23830   return jresult;
23831 }
23832
23833
23834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23835   int jresult ;
23836   Dali::Pixel::Format result;
23837
23838   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23839   jresult = (int)result;
23840   return jresult;
23841 }
23842
23843
23844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23845   int jresult ;
23846   Dali::Pixel::Format result;
23847
23848   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23849   jresult = (int)result;
23850   return jresult;
23851 }
23852
23853
23854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23855   unsigned int jresult ;
23856   Dali::Pixel::Format arg1 ;
23857   bool result;
23858
23859   arg1 = (Dali::Pixel::Format)jarg1;
23860   {
23861     try {
23862       result = (bool)Dali::Pixel::HasAlpha(arg1);
23863     } catch (std::out_of_range& e) {
23864       {
23865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23866       };
23867     } catch (std::exception& e) {
23868       {
23869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23870       };
23871     } catch (Dali::DaliException e) {
23872       {
23873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23874       };
23875     } catch (...) {
23876       {
23877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23878       };
23879     }
23880   }
23881
23882   jresult = result;
23883   return jresult;
23884 }
23885
23886
23887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23888   unsigned int jresult ;
23889   Dali::Pixel::Format arg1 ;
23890   unsigned int result;
23891
23892   arg1 = (Dali::Pixel::Format)jarg1;
23893   {
23894     try {
23895       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23896     } catch (std::out_of_range& e) {
23897       {
23898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23899       };
23900     } catch (std::exception& e) {
23901       {
23902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23903       };
23904     } catch (Dali::DaliException e) {
23905       {
23906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23907       };
23908     } catch (...) {
23909       {
23910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23911       };
23912     }
23913   }
23914
23915   jresult = result;
23916   return jresult;
23917 }
23918
23919
23920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23921   Dali::Pixel::Format arg1 ;
23922   int *arg2 = 0 ;
23923   int *arg3 = 0 ;
23924
23925   arg1 = (Dali::Pixel::Format)jarg1;
23926   arg2 = (int *)jarg2;
23927   if (!arg2) {
23928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23929     return ;
23930   }
23931   arg3 = (int *)jarg3;
23932   if (!arg3) {
23933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23934     return ;
23935   }
23936   {
23937     try {
23938       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23939     } catch (std::out_of_range& e) {
23940       {
23941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23942       };
23943     } catch (std::exception& e) {
23944       {
23945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23946       };
23947     } catch (Dali::DaliException e) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23950       };
23951     } catch (...) {
23952       {
23953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23954       };
23955     }
23956   }
23957
23958 }
23959
23960
23961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23962   void * jresult ;
23963   unsigned char *arg1 = (unsigned char *) 0 ;
23964   unsigned int arg2 ;
23965   unsigned int arg3 ;
23966   unsigned int arg4 ;
23967   Dali::Pixel::Format arg5 ;
23968   Dali::PixelData::ReleaseFunction arg6 ;
23969   Dali::PixelData result;
23970
23971   arg1 = jarg1;
23972   arg2 = (unsigned int)jarg2;
23973   arg3 = (unsigned int)jarg3;
23974   arg4 = (unsigned int)jarg4;
23975   arg5 = (Dali::Pixel::Format)jarg5;
23976   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23977   {
23978     try {
23979       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23980     } catch (std::out_of_range& e) {
23981       {
23982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23983       };
23984     } catch (std::exception& e) {
23985       {
23986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (Dali::DaliException e) {
23989       {
23990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23991       };
23992     } catch (...) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23995       };
23996     }
23997   }
23998
23999   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24000
24001
24002   return jresult;
24003 }
24004
24005
24006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24007   void * jresult ;
24008   Dali::PixelData *result = 0 ;
24009
24010   {
24011     try {
24012       result = (Dali::PixelData *)new Dali::PixelData();
24013     } catch (std::out_of_range& e) {
24014       {
24015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24016       };
24017     } catch (std::exception& e) {
24018       {
24019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (Dali::DaliException e) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24024       };
24025     } catch (...) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24028       };
24029     }
24030   }
24031
24032   jresult = (void *)result;
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24038   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24039
24040   arg1 = (Dali::PixelData *)jarg1;
24041   {
24042     try {
24043       delete arg1;
24044     } catch (std::out_of_range& e) {
24045       {
24046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24047       };
24048     } catch (std::exception& e) {
24049       {
24050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24051       };
24052     } catch (Dali::DaliException e) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24055       };
24056     } catch (...) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24059       };
24060     }
24061   }
24062
24063 }
24064
24065
24066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24067   void * jresult ;
24068   Dali::PixelData *arg1 = 0 ;
24069   Dali::PixelData *result = 0 ;
24070
24071   arg1 = (Dali::PixelData *)jarg1;
24072   if (!arg1) {
24073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24074     return 0;
24075   }
24076   {
24077     try {
24078       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24079     } catch (std::out_of_range& e) {
24080       {
24081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24082       };
24083     } catch (std::exception& e) {
24084       {
24085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (Dali::DaliException e) {
24088       {
24089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24090       };
24091     } catch (...) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24094       };
24095     }
24096   }
24097
24098   jresult = (void *)result;
24099   return jresult;
24100 }
24101
24102
24103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24104   void * jresult ;
24105   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24106   Dali::PixelData *arg2 = 0 ;
24107   Dali::PixelData *result = 0 ;
24108
24109   arg1 = (Dali::PixelData *)jarg1;
24110   arg2 = (Dali::PixelData *)jarg2;
24111   if (!arg2) {
24112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24113     return 0;
24114   }
24115   {
24116     try {
24117       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24118     } catch (std::out_of_range& e) {
24119       {
24120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24121       };
24122     } catch (std::exception& e) {
24123       {
24124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (Dali::DaliException e) {
24127       {
24128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24129       };
24130     } catch (...) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24133       };
24134     }
24135   }
24136
24137   jresult = (void *)result;
24138   return jresult;
24139 }
24140
24141
24142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24143   unsigned int jresult ;
24144   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24145   unsigned int result;
24146
24147   arg1 = (Dali::PixelData *)jarg1;
24148   {
24149     try {
24150       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24151     } catch (std::out_of_range& e) {
24152       {
24153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24154       };
24155     } catch (std::exception& e) {
24156       {
24157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (Dali::DaliException e) {
24160       {
24161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24162       };
24163     } catch (...) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24166       };
24167     }
24168   }
24169
24170   jresult = result;
24171   return jresult;
24172 }
24173
24174
24175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24176   unsigned int jresult ;
24177   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24178   unsigned int result;
24179
24180   arg1 = (Dali::PixelData *)jarg1;
24181   {
24182     try {
24183       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24184     } catch (std::out_of_range& e) {
24185       {
24186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24187       };
24188     } catch (std::exception& e) {
24189       {
24190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24191       };
24192     } catch (Dali::DaliException e) {
24193       {
24194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24195       };
24196     } catch (...) {
24197       {
24198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24199       };
24200     }
24201   }
24202
24203   jresult = result;
24204   return jresult;
24205 }
24206
24207
24208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24209   int jresult ;
24210   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24211   Dali::Pixel::Format result;
24212
24213   arg1 = (Dali::PixelData *)jarg1;
24214   {
24215     try {
24216       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24217     } catch (std::out_of_range& e) {
24218       {
24219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24220       };
24221     } catch (std::exception& e) {
24222       {
24223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24224       };
24225     } catch (Dali::DaliException e) {
24226       {
24227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24228       };
24229     } catch (...) {
24230       {
24231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24232       };
24233     }
24234   }
24235
24236   jresult = (int)result;
24237   return jresult;
24238 }
24239
24240
24241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24242   unsigned int jresult ;
24243   unsigned int result;
24244
24245   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24246   jresult = result;
24247   return jresult;
24248 }
24249
24250
24251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24252   unsigned int jresult ;
24253   unsigned int result;
24254
24255   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24256   jresult = result;
24257   return jresult;
24258 }
24259
24260
24261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24262   unsigned int jresult ;
24263   unsigned int result;
24264
24265   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24266   jresult = result;
24267   return jresult;
24268 }
24269
24270
24271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24272   unsigned int jresult ;
24273   unsigned int result;
24274
24275   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24276   jresult = result;
24277   return jresult;
24278 }
24279
24280
24281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24282   unsigned int jresult ;
24283   unsigned int result;
24284
24285   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24286   jresult = result;
24287   return jresult;
24288 }
24289
24290
24291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24292   unsigned int jresult ;
24293   unsigned int result;
24294
24295   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24296   jresult = result;
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24302   void * jresult ;
24303   Dali::TextureType::Type arg1 ;
24304   Dali::Pixel::Format arg2 ;
24305   unsigned int arg3 ;
24306   unsigned int arg4 ;
24307   Dali::Texture result;
24308
24309   arg1 = (Dali::TextureType::Type)jarg1;
24310   arg2 = (Dali::Pixel::Format)jarg2;
24311   arg3 = (unsigned int)jarg3;
24312   arg4 = (unsigned int)jarg4;
24313   {
24314     try {
24315       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24316     } catch (std::out_of_range& e) {
24317       {
24318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24319       };
24320     } catch (std::exception& e) {
24321       {
24322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24323       };
24324     } catch (Dali::DaliException e) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24327       };
24328     } catch (...) {
24329       {
24330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24331       };
24332     }
24333   }
24334
24335   jresult = new Dali::Texture((const Dali::Texture &)result);
24336   return jresult;
24337 }
24338
24339
24340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24341   void * jresult ;
24342   NativeImageInterface *arg1 = 0 ;
24343   Dali::Texture result;
24344
24345   arg1 = (NativeImageInterface *)jarg1;
24346   if (!arg1) {
24347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24348     return 0;
24349   }
24350   {
24351     try {
24352       result = Dali::Texture::New(*arg1);
24353     } catch (std::out_of_range& e) {
24354       {
24355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24356       };
24357     } catch (std::exception& e) {
24358       {
24359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (Dali::DaliException e) {
24362       {
24363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24364       };
24365     } catch (...) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24368       };
24369     }
24370   }
24371
24372   jresult = new Dali::Texture((const Dali::Texture &)result);
24373   return jresult;
24374 }
24375
24376
24377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24378   void * jresult ;
24379   Dali::Texture *result = 0 ;
24380
24381   {
24382     try {
24383       result = (Dali::Texture *)new Dali::Texture();
24384     } catch (std::out_of_range& e) {
24385       {
24386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (std::exception& e) {
24389       {
24390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (Dali::DaliException e) {
24393       {
24394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24395       };
24396     } catch (...) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24399       };
24400     }
24401   }
24402
24403   jresult = (void *)result;
24404   return jresult;
24405 }
24406
24407
24408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24409   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24410
24411   arg1 = (Dali::Texture *)jarg1;
24412   {
24413     try {
24414       delete arg1;
24415     } catch (std::out_of_range& e) {
24416       {
24417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24418       };
24419     } catch (std::exception& e) {
24420       {
24421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24422       };
24423     } catch (Dali::DaliException e) {
24424       {
24425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24426       };
24427     } catch (...) {
24428       {
24429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24430       };
24431     }
24432   }
24433
24434 }
24435
24436
24437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24438   void * jresult ;
24439   Dali::Texture *arg1 = 0 ;
24440   Dali::Texture *result = 0 ;
24441
24442   arg1 = (Dali::Texture *)jarg1;
24443   if (!arg1) {
24444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24445     return 0;
24446   }
24447   {
24448     try {
24449       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24450     } catch (std::out_of_range& e) {
24451       {
24452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24453       };
24454     } catch (std::exception& e) {
24455       {
24456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24457       };
24458     } catch (Dali::DaliException e) {
24459       {
24460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24461       };
24462     } catch (...) {
24463       {
24464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24465       };
24466     }
24467   }
24468
24469   jresult = (void *)result;
24470   return jresult;
24471 }
24472
24473
24474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24475   void * jresult ;
24476   Dali::BaseHandle arg1 ;
24477   Dali::BaseHandle *argp1 ;
24478   Dali::Texture result;
24479
24480   argp1 = (Dali::BaseHandle *)jarg1;
24481   if (!argp1) {
24482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24483     return 0;
24484   }
24485   arg1 = *argp1;
24486   {
24487     try {
24488       result = Dali::Texture::DownCast(arg1);
24489     } catch (std::out_of_range& e) {
24490       {
24491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24492       };
24493     } catch (std::exception& e) {
24494       {
24495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24496       };
24497     } catch (Dali::DaliException e) {
24498       {
24499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24500       };
24501     } catch (...) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24504       };
24505     }
24506   }
24507
24508   jresult = new Dali::Texture((const Dali::Texture &)result);
24509   return jresult;
24510 }
24511
24512
24513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24514   void * jresult ;
24515   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24516   Dali::Texture *arg2 = 0 ;
24517   Dali::Texture *result = 0 ;
24518
24519   arg1 = (Dali::Texture *)jarg1;
24520   arg2 = (Dali::Texture *)jarg2;
24521   if (!arg2) {
24522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24523     return 0;
24524   }
24525   {
24526     try {
24527       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24528     } catch (std::out_of_range& e) {
24529       {
24530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24531       };
24532     } catch (std::exception& e) {
24533       {
24534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (Dali::DaliException e) {
24537       {
24538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24539       };
24540     } catch (...) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24543       };
24544     }
24545   }
24546
24547   jresult = (void *)result;
24548   return jresult;
24549 }
24550
24551
24552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24553   unsigned int jresult ;
24554   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24555   Dali::PixelData arg2 ;
24556   Dali::PixelData *argp2 ;
24557   bool result;
24558
24559   arg1 = (Dali::Texture *)jarg1;
24560   argp2 = (Dali::PixelData *)jarg2;
24561   if (!argp2) {
24562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24563     return 0;
24564   }
24565   arg2 = *argp2;
24566   {
24567     try {
24568       result = (bool)(arg1)->Upload(arg2);
24569     } catch (std::out_of_range& e) {
24570       {
24571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24572       };
24573     } catch (std::exception& e) {
24574       {
24575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24576       };
24577     } catch (Dali::DaliException e) {
24578       {
24579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24580       };
24581     } catch (...) {
24582       {
24583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24584       };
24585     }
24586   }
24587
24588   jresult = result;
24589   return jresult;
24590 }
24591
24592
24593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24594   unsigned int jresult ;
24595   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24596   Dali::PixelData arg2 ;
24597   unsigned int arg3 ;
24598   unsigned int arg4 ;
24599   unsigned int arg5 ;
24600   unsigned int arg6 ;
24601   unsigned int arg7 ;
24602   unsigned int arg8 ;
24603   Dali::PixelData *argp2 ;
24604   bool result;
24605
24606   arg1 = (Dali::Texture *)jarg1;
24607   argp2 = (Dali::PixelData *)jarg2;
24608   if (!argp2) {
24609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24610     return 0;
24611   }
24612   arg2 = *argp2;
24613   arg3 = (unsigned int)jarg3;
24614   arg4 = (unsigned int)jarg4;
24615   arg5 = (unsigned int)jarg5;
24616   arg6 = (unsigned int)jarg6;
24617   arg7 = (unsigned int)jarg7;
24618   arg8 = (unsigned int)jarg8;
24619   {
24620     try {
24621       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24622     } catch (std::out_of_range& e) {
24623       {
24624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24625       };
24626     } catch (std::exception& e) {
24627       {
24628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (Dali::DaliException e) {
24631       {
24632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24633       };
24634     } catch (...) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24637       };
24638     }
24639   }
24640
24641   jresult = result;
24642   return jresult;
24643 }
24644
24645
24646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24647   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24648
24649   arg1 = (Dali::Texture *)jarg1;
24650   {
24651     try {
24652       (arg1)->GenerateMipmaps();
24653     } catch (std::out_of_range& e) {
24654       {
24655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24656       };
24657     } catch (std::exception& e) {
24658       {
24659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24660       };
24661     } catch (Dali::DaliException e) {
24662       {
24663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24664       };
24665     } catch (...) {
24666       {
24667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24668       };
24669     }
24670   }
24671
24672 }
24673
24674
24675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24676   unsigned int jresult ;
24677   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24678   unsigned int result;
24679
24680   arg1 = (Dali::Texture *)jarg1;
24681   {
24682     try {
24683       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24684     } catch (std::out_of_range& e) {
24685       {
24686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24687       };
24688     } catch (std::exception& e) {
24689       {
24690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24691       };
24692     } catch (Dali::DaliException e) {
24693       {
24694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24695       };
24696     } catch (...) {
24697       {
24698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24699       };
24700     }
24701   }
24702
24703   jresult = result;
24704   return jresult;
24705 }
24706
24707
24708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24709   unsigned int jresult ;
24710   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24711   unsigned int result;
24712
24713   arg1 = (Dali::Texture *)jarg1;
24714   {
24715     try {
24716       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24717     } catch (std::out_of_range& e) {
24718       {
24719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24720       };
24721     } catch (std::exception& e) {
24722       {
24723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24724       };
24725     } catch (Dali::DaliException e) {
24726       {
24727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24728       };
24729     } catch (...) {
24730       {
24731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24732       };
24733     }
24734   }
24735
24736   jresult = result;
24737   return jresult;
24738 }
24739
24740
24741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24742   void * jresult ;
24743   Dali::Sampler result;
24744
24745   {
24746     try {
24747       result = Dali::Sampler::New();
24748     } catch (std::out_of_range& e) {
24749       {
24750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24751       };
24752     } catch (std::exception& e) {
24753       {
24754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24755       };
24756     } catch (Dali::DaliException e) {
24757       {
24758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24759       };
24760     } catch (...) {
24761       {
24762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24763       };
24764     }
24765   }
24766
24767   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24768   return jresult;
24769 }
24770
24771
24772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24773   void * jresult ;
24774   Dali::Sampler *result = 0 ;
24775
24776   {
24777     try {
24778       result = (Dali::Sampler *)new Dali::Sampler();
24779     } catch (std::out_of_range& e) {
24780       {
24781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24782       };
24783     } catch (std::exception& e) {
24784       {
24785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24786       };
24787     } catch (Dali::DaliException e) {
24788       {
24789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24790       };
24791     } catch (...) {
24792       {
24793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24794       };
24795     }
24796   }
24797
24798   jresult = (void *)result;
24799   return jresult;
24800 }
24801
24802
24803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24804   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24805
24806   arg1 = (Dali::Sampler *)jarg1;
24807   {
24808     try {
24809       delete arg1;
24810     } catch (std::out_of_range& e) {
24811       {
24812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24813       };
24814     } catch (std::exception& e) {
24815       {
24816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (Dali::DaliException e) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24821       };
24822     } catch (...) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24825       };
24826     }
24827   }
24828
24829 }
24830
24831
24832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24833   void * jresult ;
24834   Dali::Sampler *arg1 = 0 ;
24835   Dali::Sampler *result = 0 ;
24836
24837   arg1 = (Dali::Sampler *)jarg1;
24838   if (!arg1) {
24839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24840     return 0;
24841   }
24842   {
24843     try {
24844       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24845     } catch (std::out_of_range& e) {
24846       {
24847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24848       };
24849     } catch (std::exception& e) {
24850       {
24851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24852       };
24853     } catch (Dali::DaliException e) {
24854       {
24855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24856       };
24857     } catch (...) {
24858       {
24859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24860       };
24861     }
24862   }
24863
24864   jresult = (void *)result;
24865   return jresult;
24866 }
24867
24868
24869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24870   void * jresult ;
24871   Dali::BaseHandle arg1 ;
24872   Dali::BaseHandle *argp1 ;
24873   Dali::Sampler result;
24874
24875   argp1 = (Dali::BaseHandle *)jarg1;
24876   if (!argp1) {
24877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24878     return 0;
24879   }
24880   arg1 = *argp1;
24881   {
24882     try {
24883       result = Dali::Sampler::DownCast(arg1);
24884     } catch (std::out_of_range& e) {
24885       {
24886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24887       };
24888     } catch (std::exception& e) {
24889       {
24890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24891       };
24892     } catch (Dali::DaliException e) {
24893       {
24894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24895       };
24896     } catch (...) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24899       };
24900     }
24901   }
24902
24903   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24904   return jresult;
24905 }
24906
24907
24908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24909   void * jresult ;
24910   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24911   Dali::Sampler *arg2 = 0 ;
24912   Dali::Sampler *result = 0 ;
24913
24914   arg1 = (Dali::Sampler *)jarg1;
24915   arg2 = (Dali::Sampler *)jarg2;
24916   if (!arg2) {
24917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24918     return 0;
24919   }
24920   {
24921     try {
24922       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24923     } catch (std::out_of_range& e) {
24924       {
24925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24926       };
24927     } catch (std::exception& e) {
24928       {
24929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24930       };
24931     } catch (Dali::DaliException e) {
24932       {
24933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24934       };
24935     } catch (...) {
24936       {
24937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24938       };
24939     }
24940   }
24941
24942   jresult = (void *)result;
24943   return jresult;
24944 }
24945
24946
24947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24948   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24949   Dali::FilterMode::Type arg2 ;
24950   Dali::FilterMode::Type arg3 ;
24951
24952   arg1 = (Dali::Sampler *)jarg1;
24953   arg2 = (Dali::FilterMode::Type)jarg2;
24954   arg3 = (Dali::FilterMode::Type)jarg3;
24955   {
24956     try {
24957       (arg1)->SetFilterMode(arg2,arg3);
24958     } catch (std::out_of_range& e) {
24959       {
24960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24961       };
24962     } catch (std::exception& e) {
24963       {
24964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (Dali::DaliException e) {
24967       {
24968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24969       };
24970     } catch (...) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24973       };
24974     }
24975   }
24976
24977 }
24978
24979
24980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24981   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24982   Dali::WrapMode::Type arg2 ;
24983   Dali::WrapMode::Type arg3 ;
24984
24985   arg1 = (Dali::Sampler *)jarg1;
24986   arg2 = (Dali::WrapMode::Type)jarg2;
24987   arg3 = (Dali::WrapMode::Type)jarg3;
24988   {
24989     try {
24990       (arg1)->SetWrapMode(arg2,arg3);
24991     } catch (std::out_of_range& e) {
24992       {
24993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24994       };
24995     } catch (std::exception& e) {
24996       {
24997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (Dali::DaliException e) {
25000       {
25001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25002       };
25003     } catch (...) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25006       };
25007     }
25008   }
25009
25010 }
25011
25012
25013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25014   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25015   Dali::WrapMode::Type arg2 ;
25016   Dali::WrapMode::Type arg3 ;
25017   Dali::WrapMode::Type arg4 ;
25018
25019   arg1 = (Dali::Sampler *)jarg1;
25020   arg2 = (Dali::WrapMode::Type)jarg2;
25021   arg3 = (Dali::WrapMode::Type)jarg3;
25022   arg4 = (Dali::WrapMode::Type)jarg4;
25023   {
25024     try {
25025       (arg1)->SetWrapMode(arg2,arg3,arg4);
25026     } catch (std::out_of_range& e) {
25027       {
25028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25029       };
25030     } catch (std::exception& e) {
25031       {
25032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25033       };
25034     } catch (Dali::DaliException e) {
25035       {
25036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25037       };
25038     } catch (...) {
25039       {
25040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25041       };
25042     }
25043   }
25044
25045 }
25046
25047
25048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25049   void * jresult ;
25050   Dali::TextureSet result;
25051
25052   {
25053     try {
25054       result = Dali::TextureSet::New();
25055     } catch (std::out_of_range& e) {
25056       {
25057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25058       };
25059     } catch (std::exception& e) {
25060       {
25061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25062       };
25063     } catch (Dali::DaliException e) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25066       };
25067     } catch (...) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25070       };
25071     }
25072   }
25073
25074   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25075   return jresult;
25076 }
25077
25078
25079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25080   void * jresult ;
25081   Dali::TextureSet *result = 0 ;
25082
25083   {
25084     try {
25085       result = (Dali::TextureSet *)new Dali::TextureSet();
25086     } catch (std::out_of_range& e) {
25087       {
25088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25089       };
25090     } catch (std::exception& e) {
25091       {
25092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (Dali::DaliException e) {
25095       {
25096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25097       };
25098     } catch (...) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25101       };
25102     }
25103   }
25104
25105   jresult = (void *)result;
25106   return jresult;
25107 }
25108
25109
25110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25111   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25112
25113   arg1 = (Dali::TextureSet *)jarg1;
25114   {
25115     try {
25116       delete arg1;
25117     } catch (std::out_of_range& e) {
25118       {
25119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25120       };
25121     } catch (std::exception& e) {
25122       {
25123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (Dali::DaliException e) {
25126       {
25127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25128       };
25129     } catch (...) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25132       };
25133     }
25134   }
25135
25136 }
25137
25138
25139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25140   void * jresult ;
25141   Dali::TextureSet *arg1 = 0 ;
25142   Dali::TextureSet *result = 0 ;
25143
25144   arg1 = (Dali::TextureSet *)jarg1;
25145   if (!arg1) {
25146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25147     return 0;
25148   }
25149   {
25150     try {
25151       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25152     } catch (std::out_of_range& e) {
25153       {
25154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25155       };
25156     } catch (std::exception& e) {
25157       {
25158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25159       };
25160     } catch (Dali::DaliException e) {
25161       {
25162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25163       };
25164     } catch (...) {
25165       {
25166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25167       };
25168     }
25169   }
25170
25171   jresult = (void *)result;
25172   return jresult;
25173 }
25174
25175
25176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25177   void * jresult ;
25178   Dali::BaseHandle arg1 ;
25179   Dali::BaseHandle *argp1 ;
25180   Dali::TextureSet result;
25181
25182   argp1 = (Dali::BaseHandle *)jarg1;
25183   if (!argp1) {
25184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25185     return 0;
25186   }
25187   arg1 = *argp1;
25188   {
25189     try {
25190       result = Dali::TextureSet::DownCast(arg1);
25191     } catch (std::out_of_range& e) {
25192       {
25193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25194       };
25195     } catch (std::exception& e) {
25196       {
25197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (Dali::DaliException e) {
25200       {
25201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25202       };
25203     } catch (...) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25206       };
25207     }
25208   }
25209
25210   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25211   return jresult;
25212 }
25213
25214
25215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25216   void * jresult ;
25217   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25218   Dali::TextureSet *arg2 = 0 ;
25219   Dali::TextureSet *result = 0 ;
25220
25221   arg1 = (Dali::TextureSet *)jarg1;
25222   arg2 = (Dali::TextureSet *)jarg2;
25223   if (!arg2) {
25224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25225     return 0;
25226   }
25227   {
25228     try {
25229       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25230     } catch (std::out_of_range& e) {
25231       {
25232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25233       };
25234     } catch (std::exception& e) {
25235       {
25236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (Dali::DaliException e) {
25239       {
25240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25241       };
25242     } catch (...) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25245       };
25246     }
25247   }
25248
25249   jresult = (void *)result;
25250   return jresult;
25251 }
25252
25253
25254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25255   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25256   size_t arg2 ;
25257   Dali::Texture arg3 ;
25258   Dali::Texture *argp3 ;
25259
25260   arg1 = (Dali::TextureSet *)jarg1;
25261   arg2 = (size_t)jarg2;
25262   argp3 = (Dali::Texture *)jarg3;
25263   if (!argp3) {
25264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25265     return ;
25266   }
25267   arg3 = *argp3;
25268   {
25269     try {
25270       (arg1)->SetTexture(arg2,arg3);
25271     } catch (std::out_of_range& e) {
25272       {
25273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25274       };
25275     } catch (std::exception& e) {
25276       {
25277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (Dali::DaliException e) {
25280       {
25281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25282       };
25283     } catch (...) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25286       };
25287     }
25288   }
25289
25290 }
25291
25292
25293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25294   void * jresult ;
25295   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25296   size_t arg2 ;
25297   Dali::Texture result;
25298
25299   arg1 = (Dali::TextureSet *)jarg1;
25300   arg2 = (size_t)jarg2;
25301   {
25302     try {
25303       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25304     } catch (std::out_of_range& e) {
25305       {
25306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25307       };
25308     } catch (std::exception& e) {
25309       {
25310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (Dali::DaliException e) {
25313       {
25314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25315       };
25316     } catch (...) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25319       };
25320     }
25321   }
25322
25323   jresult = new Dali::Texture((const Dali::Texture &)result);
25324   return jresult;
25325 }
25326
25327
25328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25330   size_t arg2 ;
25331   Dali::Sampler arg3 ;
25332   Dali::Sampler *argp3 ;
25333
25334   arg1 = (Dali::TextureSet *)jarg1;
25335   arg2 = (size_t)jarg2;
25336   argp3 = (Dali::Sampler *)jarg3;
25337   if (!argp3) {
25338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25339     return ;
25340   }
25341   arg3 = *argp3;
25342   {
25343     try {
25344       (arg1)->SetSampler(arg2,arg3);
25345     } catch (std::out_of_range& e) {
25346       {
25347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25348       };
25349     } catch (std::exception& e) {
25350       {
25351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (Dali::DaliException e) {
25354       {
25355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25356       };
25357     } catch (...) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25360       };
25361     }
25362   }
25363
25364 }
25365
25366
25367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25368   void * jresult ;
25369   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25370   size_t arg2 ;
25371   Dali::Sampler result;
25372
25373   arg1 = (Dali::TextureSet *)jarg1;
25374   arg2 = (size_t)jarg2;
25375   {
25376     try {
25377       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25378     } catch (std::out_of_range& e) {
25379       {
25380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25381       };
25382     } catch (std::exception& e) {
25383       {
25384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25385       };
25386     } catch (Dali::DaliException e) {
25387       {
25388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25389       };
25390     } catch (...) {
25391       {
25392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25393       };
25394     }
25395   }
25396
25397   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25398   return jresult;
25399 }
25400
25401
25402 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25403   unsigned long jresult ;
25404   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25405   size_t result;
25406
25407   arg1 = (Dali::TextureSet *)jarg1;
25408   {
25409     try {
25410       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25411     } catch (std::out_of_range& e) {
25412       {
25413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25414       };
25415     } catch (std::exception& e) {
25416       {
25417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (Dali::DaliException e) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25422       };
25423     } catch (...) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25426       };
25427     }
25428   }
25429
25430   jresult = (unsigned long)result;
25431   return jresult;
25432 }
25433
25434
25435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25436   void * jresult ;
25437   Dali::Property::Map *arg1 = 0 ;
25438   Dali::PropertyBuffer result;
25439
25440   arg1 = (Dali::Property::Map *)jarg1;
25441   if (!arg1) {
25442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25443     return 0;
25444   }
25445   {
25446     try {
25447       result = Dali::PropertyBuffer::New(*arg1);
25448     } catch (std::out_of_range& e) {
25449       {
25450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25451       };
25452     } catch (std::exception& e) {
25453       {
25454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (Dali::DaliException e) {
25457       {
25458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25459       };
25460     } catch (...) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25463       };
25464     }
25465   }
25466
25467   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25468   return jresult;
25469 }
25470
25471
25472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25473   void * jresult ;
25474   Dali::PropertyBuffer *result = 0 ;
25475
25476   {
25477     try {
25478       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25479     } catch (std::out_of_range& e) {
25480       {
25481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25482       };
25483     } catch (std::exception& e) {
25484       {
25485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25486       };
25487     } catch (Dali::DaliException e) {
25488       {
25489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25490       };
25491     } catch (...) {
25492       {
25493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25494       };
25495     }
25496   }
25497
25498   jresult = (void *)result;
25499   return jresult;
25500 }
25501
25502
25503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25504   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25505
25506   arg1 = (Dali::PropertyBuffer *)jarg1;
25507   {
25508     try {
25509       delete arg1;
25510     } catch (std::out_of_range& e) {
25511       {
25512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25513       };
25514     } catch (std::exception& e) {
25515       {
25516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25517       };
25518     } catch (Dali::DaliException e) {
25519       {
25520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25521       };
25522     } catch (...) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25525       };
25526     }
25527   }
25528
25529 }
25530
25531
25532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25533   void * jresult ;
25534   Dali::PropertyBuffer *arg1 = 0 ;
25535   Dali::PropertyBuffer *result = 0 ;
25536
25537   arg1 = (Dali::PropertyBuffer *)jarg1;
25538   if (!arg1) {
25539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25540     return 0;
25541   }
25542   {
25543     try {
25544       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25545     } catch (std::out_of_range& e) {
25546       {
25547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25548       };
25549     } catch (std::exception& e) {
25550       {
25551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (Dali::DaliException e) {
25554       {
25555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25556       };
25557     } catch (...) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25560       };
25561     }
25562   }
25563
25564   jresult = (void *)result;
25565   return jresult;
25566 }
25567
25568
25569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25570   void * jresult ;
25571   Dali::BaseHandle arg1 ;
25572   Dali::BaseHandle *argp1 ;
25573   Dali::PropertyBuffer result;
25574
25575   argp1 = (Dali::BaseHandle *)jarg1;
25576   if (!argp1) {
25577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25578     return 0;
25579   }
25580   arg1 = *argp1;
25581   {
25582     try {
25583       result = Dali::PropertyBuffer::DownCast(arg1);
25584     } catch (std::out_of_range& e) {
25585       {
25586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25587       };
25588     } catch (std::exception& e) {
25589       {
25590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25591       };
25592     } catch (Dali::DaliException e) {
25593       {
25594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25595       };
25596     } catch (...) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25599       };
25600     }
25601   }
25602
25603   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25604   return jresult;
25605 }
25606
25607
25608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25609   void * jresult ;
25610   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25611   Dali::PropertyBuffer *arg2 = 0 ;
25612   Dali::PropertyBuffer *result = 0 ;
25613
25614   arg1 = (Dali::PropertyBuffer *)jarg1;
25615   arg2 = (Dali::PropertyBuffer *)jarg2;
25616   if (!arg2) {
25617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25618     return 0;
25619   }
25620   {
25621     try {
25622       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25623     } catch (std::out_of_range& e) {
25624       {
25625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25626       };
25627     } catch (std::exception& e) {
25628       {
25629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (Dali::DaliException e) {
25632       {
25633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25634       };
25635     } catch (...) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25638       };
25639     }
25640   }
25641
25642   jresult = (void *)result;
25643   return jresult;
25644 }
25645
25646
25647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25648   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25649   void *arg2 = (void *) 0 ;
25650   std::size_t arg3 ;
25651
25652   arg1 = (Dali::PropertyBuffer *)jarg1;
25653   arg2 = jarg2;
25654   arg3 = (std::size_t)jarg3;
25655   {
25656     try {
25657       (arg1)->SetData((void const *)arg2,arg3);
25658     } catch (std::out_of_range& e) {
25659       {
25660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25661       };
25662     } catch (std::exception& e) {
25663       {
25664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (Dali::DaliException e) {
25667       {
25668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25669       };
25670     } catch (...) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25673       };
25674     }
25675   }
25676
25677 }
25678
25679
25680 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25681   unsigned long jresult ;
25682   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25683   std::size_t result;
25684
25685   arg1 = (Dali::PropertyBuffer *)jarg1;
25686   {
25687     try {
25688       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25689     } catch (std::out_of_range& e) {
25690       {
25691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25692       };
25693     } catch (std::exception& e) {
25694       {
25695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25696       };
25697     } catch (Dali::DaliException e) {
25698       {
25699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25700       };
25701     } catch (...) {
25702       {
25703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25704       };
25705     }
25706   }
25707
25708   jresult = (unsigned long)result;
25709   return jresult;
25710 }
25711
25712
25713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25714   void * jresult ;
25715   Dali::Geometry result;
25716
25717   {
25718     try {
25719       result = Dali::Geometry::New();
25720     } catch (std::out_of_range& e) {
25721       {
25722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25723       };
25724     } catch (std::exception& e) {
25725       {
25726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25727       };
25728     } catch (Dali::DaliException e) {
25729       {
25730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25731       };
25732     } catch (...) {
25733       {
25734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25735       };
25736     }
25737   }
25738
25739   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25740   return jresult;
25741 }
25742
25743
25744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25745   void * jresult ;
25746   Dali::Geometry *result = 0 ;
25747
25748   {
25749     try {
25750       result = (Dali::Geometry *)new Dali::Geometry();
25751     } catch (std::out_of_range& e) {
25752       {
25753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25754       };
25755     } catch (std::exception& e) {
25756       {
25757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (Dali::DaliException e) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25762       };
25763     } catch (...) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25766       };
25767     }
25768   }
25769
25770   jresult = (void *)result;
25771   return jresult;
25772 }
25773
25774
25775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25776   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25777
25778   arg1 = (Dali::Geometry *)jarg1;
25779   {
25780     try {
25781       delete arg1;
25782     } catch (std::out_of_range& e) {
25783       {
25784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25785       };
25786     } catch (std::exception& e) {
25787       {
25788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (Dali::DaliException e) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25797       };
25798     }
25799   }
25800
25801 }
25802
25803
25804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25805   void * jresult ;
25806   Dali::Geometry *arg1 = 0 ;
25807   Dali::Geometry *result = 0 ;
25808
25809   arg1 = (Dali::Geometry *)jarg1;
25810   if (!arg1) {
25811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25812     return 0;
25813   }
25814   {
25815     try {
25816       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25817     } catch (std::out_of_range& e) {
25818       {
25819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25820       };
25821     } catch (std::exception& e) {
25822       {
25823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25824       };
25825     } catch (Dali::DaliException e) {
25826       {
25827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25828       };
25829     } catch (...) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25832       };
25833     }
25834   }
25835
25836   jresult = (void *)result;
25837   return jresult;
25838 }
25839
25840
25841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25842   void * jresult ;
25843   Dali::BaseHandle arg1 ;
25844   Dali::BaseHandle *argp1 ;
25845   Dali::Geometry result;
25846
25847   argp1 = (Dali::BaseHandle *)jarg1;
25848   if (!argp1) {
25849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25850     return 0;
25851   }
25852   arg1 = *argp1;
25853   {
25854     try {
25855       result = Dali::Geometry::DownCast(arg1);
25856     } catch (std::out_of_range& e) {
25857       {
25858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25859       };
25860     } catch (std::exception& e) {
25861       {
25862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (Dali::DaliException e) {
25865       {
25866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25867       };
25868     } catch (...) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25871       };
25872     }
25873   }
25874
25875   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25876   return jresult;
25877 }
25878
25879
25880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25881   void * jresult ;
25882   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25883   Dali::Geometry *arg2 = 0 ;
25884   Dali::Geometry *result = 0 ;
25885
25886   arg1 = (Dali::Geometry *)jarg1;
25887   arg2 = (Dali::Geometry *)jarg2;
25888   if (!arg2) {
25889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25890     return 0;
25891   }
25892   {
25893     try {
25894       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25895     } catch (std::out_of_range& e) {
25896       {
25897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25898       };
25899     } catch (std::exception& e) {
25900       {
25901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (Dali::DaliException e) {
25904       {
25905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25906       };
25907     } catch (...) {
25908       {
25909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25910       };
25911     }
25912   }
25913
25914   jresult = (void *)result;
25915   return jresult;
25916 }
25917
25918
25919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25920   unsigned long jresult ;
25921   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25922   Dali::PropertyBuffer *arg2 = 0 ;
25923   std::size_t result;
25924
25925   arg1 = (Dali::Geometry *)jarg1;
25926   arg2 = (Dali::PropertyBuffer *)jarg2;
25927   if (!arg2) {
25928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25929     return 0;
25930   }
25931   {
25932     try {
25933       result = (arg1)->AddVertexBuffer(*arg2);
25934     } catch (std::out_of_range& e) {
25935       {
25936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25937       };
25938     } catch (std::exception& e) {
25939       {
25940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25941       };
25942     } catch (Dali::DaliException e) {
25943       {
25944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25945       };
25946     } catch (...) {
25947       {
25948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25949       };
25950     }
25951   }
25952
25953   jresult = (unsigned long)result;
25954   return jresult;
25955 }
25956
25957
25958 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25959   unsigned long jresult ;
25960   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25961   std::size_t result;
25962
25963   arg1 = (Dali::Geometry *)jarg1;
25964   {
25965     try {
25966       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25967     } catch (std::out_of_range& e) {
25968       {
25969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25970       };
25971     } catch (std::exception& e) {
25972       {
25973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (Dali::DaliException e) {
25976       {
25977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25978       };
25979     } catch (...) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25982       };
25983     }
25984   }
25985
25986   jresult = (unsigned long)result;
25987   return jresult;
25988 }
25989
25990
25991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25992   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25993   std::size_t arg2 ;
25994
25995   arg1 = (Dali::Geometry *)jarg1;
25996   arg2 = (std::size_t)jarg2;
25997   {
25998     try {
25999       (arg1)->RemoveVertexBuffer(arg2);
26000     } catch (std::out_of_range& e) {
26001       {
26002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26003       };
26004     } catch (std::exception& e) {
26005       {
26006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (Dali::DaliException e) {
26009       {
26010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26011       };
26012     } catch (...) {
26013       {
26014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26015       };
26016     }
26017   }
26018
26019 }
26020
26021
26022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26023   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26024   unsigned short *arg2 = (unsigned short *) 0 ;
26025   size_t arg3 ;
26026
26027   arg1 = (Dali::Geometry *)jarg1;
26028   arg2 = jarg2;
26029   arg3 = (size_t)jarg3;
26030   {
26031     try {
26032       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26033     } catch (std::out_of_range& e) {
26034       {
26035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26036       };
26037     } catch (std::exception& e) {
26038       {
26039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26040       };
26041     } catch (Dali::DaliException e) {
26042       {
26043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26044       };
26045     } catch (...) {
26046       {
26047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26048       };
26049     }
26050   }
26051
26052
26053
26054 }
26055
26056
26057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26058   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26059   Dali::Geometry::Type arg2 ;
26060
26061   arg1 = (Dali::Geometry *)jarg1;
26062   arg2 = (Dali::Geometry::Type)jarg2;
26063   {
26064     try {
26065       (arg1)->SetType(arg2);
26066     } catch (std::out_of_range& e) {
26067       {
26068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26069       };
26070     } catch (std::exception& e) {
26071       {
26072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26073       };
26074     } catch (Dali::DaliException e) {
26075       {
26076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26077       };
26078     } catch (...) {
26079       {
26080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26081       };
26082     }
26083   }
26084
26085 }
26086
26087
26088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26089   int jresult ;
26090   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26091   Dali::Geometry::Type result;
26092
26093   arg1 = (Dali::Geometry *)jarg1;
26094   {
26095     try {
26096       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26097     } catch (std::out_of_range& e) {
26098       {
26099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26100       };
26101     } catch (std::exception& e) {
26102       {
26103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26104       };
26105     } catch (Dali::DaliException e) {
26106       {
26107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26108       };
26109     } catch (...) {
26110       {
26111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26112       };
26113     }
26114   }
26115
26116   jresult = (int)result;
26117   return jresult;
26118 }
26119
26120
26121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26122   void * jresult ;
26123   Dali::Shader::Hint *result = 0 ;
26124
26125   {
26126     try {
26127       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26128     } catch (std::out_of_range& e) {
26129       {
26130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26131       };
26132     } catch (std::exception& e) {
26133       {
26134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26135       };
26136     } catch (Dali::DaliException e) {
26137       {
26138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26139       };
26140     } catch (...) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26143       };
26144     }
26145   }
26146
26147   jresult = (void *)result;
26148   return jresult;
26149 }
26150
26151
26152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26153   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26154
26155   arg1 = (Dali::Shader::Hint *)jarg1;
26156   {
26157     try {
26158       delete arg1;
26159     } catch (std::out_of_range& e) {
26160       {
26161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26162       };
26163     } catch (std::exception& e) {
26164       {
26165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26166       };
26167     } catch (Dali::DaliException e) {
26168       {
26169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26170       };
26171     } catch (...) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26174       };
26175     }
26176   }
26177
26178 }
26179
26180
26181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26182   int jresult ;
26183   int result;
26184
26185   result = (int)Dali::Shader::Property::PROGRAM;
26186   jresult = (int)result;
26187   return jresult;
26188 }
26189
26190
26191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26192   void * jresult ;
26193   Dali::Shader::Property *result = 0 ;
26194
26195   {
26196     try {
26197       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26198     } catch (std::out_of_range& e) {
26199       {
26200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26201       };
26202     } catch (std::exception& e) {
26203       {
26204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (Dali::DaliException e) {
26207       {
26208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26209       };
26210     } catch (...) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26213       };
26214     }
26215   }
26216
26217   jresult = (void *)result;
26218   return jresult;
26219 }
26220
26221
26222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26223   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26224
26225   arg1 = (Dali::Shader::Property *)jarg1;
26226   {
26227     try {
26228       delete arg1;
26229     } catch (std::out_of_range& e) {
26230       {
26231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26232       };
26233     } catch (std::exception& e) {
26234       {
26235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26236       };
26237     } catch (Dali::DaliException e) {
26238       {
26239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26240       };
26241     } catch (...) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26244       };
26245     }
26246   }
26247
26248 }
26249
26250
26251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26252   void * jresult ;
26253   std::string *arg1 = 0 ;
26254   std::string *arg2 = 0 ;
26255   Dali::Shader::Hint::Value arg3 ;
26256   Dali::Shader result;
26257
26258   if (!jarg1) {
26259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26260     return 0;
26261   }
26262   std::string arg1_str(jarg1);
26263   arg1 = &arg1_str;
26264   if (!jarg2) {
26265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26266     return 0;
26267   }
26268   std::string arg2_str(jarg2);
26269   arg2 = &arg2_str;
26270   arg3 = (Dali::Shader::Hint::Value)jarg3;
26271   {
26272     try {
26273       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26274     } catch (std::out_of_range& e) {
26275       {
26276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (std::exception& e) {
26279       {
26280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (Dali::DaliException e) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26285       };
26286     } catch (...) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26289       };
26290     }
26291   }
26292
26293   jresult = new Dali::Shader((const Dali::Shader &)result);
26294
26295   //argout typemap for const std::string&
26296
26297
26298   //argout typemap for const std::string&
26299
26300   return jresult;
26301 }
26302
26303
26304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26305   void * jresult ;
26306   std::string *arg1 = 0 ;
26307   std::string *arg2 = 0 ;
26308   Dali::Shader result;
26309
26310   if (!jarg1) {
26311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26312     return 0;
26313   }
26314   std::string arg1_str(jarg1);
26315   arg1 = &arg1_str;
26316   if (!jarg2) {
26317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26318     return 0;
26319   }
26320   std::string arg2_str(jarg2);
26321   arg2 = &arg2_str;
26322   {
26323     try {
26324       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26325     } catch (std::out_of_range& e) {
26326       {
26327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26328       };
26329     } catch (std::exception& e) {
26330       {
26331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26332       };
26333     } catch (Dali::DaliException e) {
26334       {
26335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26336       };
26337     } catch (...) {
26338       {
26339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26340       };
26341     }
26342   }
26343
26344   jresult = new Dali::Shader((const Dali::Shader &)result);
26345
26346   //argout typemap for const std::string&
26347
26348
26349   //argout typemap for const std::string&
26350
26351   return jresult;
26352 }
26353
26354
26355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26356   void * jresult ;
26357   Dali::Shader *result = 0 ;
26358
26359   {
26360     try {
26361       result = (Dali::Shader *)new Dali::Shader();
26362     } catch (std::out_of_range& e) {
26363       {
26364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26365       };
26366     } catch (std::exception& e) {
26367       {
26368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (Dali::DaliException e) {
26371       {
26372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26373       };
26374     } catch (...) {
26375       {
26376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26377       };
26378     }
26379   }
26380
26381   jresult = (void *)result;
26382   return jresult;
26383 }
26384
26385
26386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26387   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26388
26389   arg1 = (Dali::Shader *)jarg1;
26390   {
26391     try {
26392       delete arg1;
26393     } catch (std::out_of_range& e) {
26394       {
26395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26396       };
26397     } catch (std::exception& e) {
26398       {
26399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26400       };
26401     } catch (Dali::DaliException e) {
26402       {
26403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26404       };
26405     } catch (...) {
26406       {
26407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26408       };
26409     }
26410   }
26411
26412 }
26413
26414
26415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26416   void * jresult ;
26417   Dali::Shader *arg1 = 0 ;
26418   Dali::Shader *result = 0 ;
26419
26420   arg1 = (Dali::Shader *)jarg1;
26421   if (!arg1) {
26422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26423     return 0;
26424   }
26425   {
26426     try {
26427       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26428     } catch (std::out_of_range& e) {
26429       {
26430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26431       };
26432     } catch (std::exception& e) {
26433       {
26434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (Dali::DaliException e) {
26437       {
26438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26439       };
26440     } catch (...) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26443       };
26444     }
26445   }
26446
26447   jresult = (void *)result;
26448   return jresult;
26449 }
26450
26451
26452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26453   void * jresult ;
26454   Dali::BaseHandle arg1 ;
26455   Dali::BaseHandle *argp1 ;
26456   Dali::Shader result;
26457
26458   argp1 = (Dali::BaseHandle *)jarg1;
26459   if (!argp1) {
26460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26461     return 0;
26462   }
26463   arg1 = *argp1;
26464   {
26465     try {
26466       result = Dali::Shader::DownCast(arg1);
26467     } catch (std::out_of_range& e) {
26468       {
26469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26470       };
26471     } catch (std::exception& e) {
26472       {
26473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (Dali::DaliException e) {
26476       {
26477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26478       };
26479     } catch (...) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26482       };
26483     }
26484   }
26485
26486   jresult = new Dali::Shader((const Dali::Shader &)result);
26487   return jresult;
26488 }
26489
26490
26491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26492   void * jresult ;
26493   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26494   Dali::Shader *arg2 = 0 ;
26495   Dali::Shader *result = 0 ;
26496
26497   arg1 = (Dali::Shader *)jarg1;
26498   arg2 = (Dali::Shader *)jarg2;
26499   if (!arg2) {
26500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26501     return 0;
26502   }
26503   {
26504     try {
26505       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26506     } catch (std::out_of_range& e) {
26507       {
26508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26509       };
26510     } catch (std::exception& e) {
26511       {
26512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26513       };
26514     } catch (Dali::DaliException e) {
26515       {
26516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26517       };
26518     } catch (...) {
26519       {
26520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26521       };
26522     }
26523   }
26524
26525   jresult = (void *)result;
26526   return jresult;
26527 }
26528
26529
26530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26531   int jresult ;
26532   int result;
26533
26534   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26535   jresult = (int)result;
26536   return jresult;
26537 }
26538
26539
26540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26541   int jresult ;
26542   int result;
26543
26544   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26545   jresult = (int)result;
26546   return jresult;
26547 }
26548
26549
26550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26551   int jresult ;
26552   int result;
26553
26554   result = (int)Dali::Renderer::Property::BLEND_MODE;
26555   jresult = (int)result;
26556   return jresult;
26557 }
26558
26559
26560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26561   int jresult ;
26562   int result;
26563
26564   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26565   jresult = (int)result;
26566   return jresult;
26567 }
26568
26569
26570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26571   int jresult ;
26572   int result;
26573
26574   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26575   jresult = (int)result;
26576   return jresult;
26577 }
26578
26579
26580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26581   int jresult ;
26582   int result;
26583
26584   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26585   jresult = (int)result;
26586   return jresult;
26587 }
26588
26589
26590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26591   int jresult ;
26592   int result;
26593
26594   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26595   jresult = (int)result;
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26601   int jresult ;
26602   int result;
26603
26604   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26605   jresult = (int)result;
26606   return jresult;
26607 }
26608
26609
26610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26611   int jresult ;
26612   int result;
26613
26614   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26615   jresult = (int)result;
26616   return jresult;
26617 }
26618
26619
26620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26621   int jresult ;
26622   int result;
26623
26624   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26625   jresult = (int)result;
26626   return jresult;
26627 }
26628
26629
26630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26631   int jresult ;
26632   int result;
26633
26634   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26635   jresult = (int)result;
26636   return jresult;
26637 }
26638
26639
26640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26641   int jresult ;
26642   int result;
26643
26644   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26645   jresult = (int)result;
26646   return jresult;
26647 }
26648
26649
26650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26651   int jresult ;
26652   int result;
26653
26654   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26655   jresult = (int)result;
26656   return jresult;
26657 }
26658
26659
26660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26661   int jresult ;
26662   int result;
26663
26664   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26665   jresult = (int)result;
26666   return jresult;
26667 }
26668
26669
26670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26671   int jresult ;
26672   int result;
26673
26674   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26675   jresult = (int)result;
26676   return jresult;
26677 }
26678
26679
26680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26681   int jresult ;
26682   int result;
26683
26684   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26685   jresult = (int)result;
26686   return jresult;
26687 }
26688
26689
26690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26691   int jresult ;
26692   int result;
26693
26694   result = (int)Dali::Renderer::Property::RENDER_MODE;
26695   jresult = (int)result;
26696   return jresult;
26697 }
26698
26699
26700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26701   int jresult ;
26702   int result;
26703
26704   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26705   jresult = (int)result;
26706   return jresult;
26707 }
26708
26709
26710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26711   int jresult ;
26712   int result;
26713
26714   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26715   jresult = (int)result;
26716   return jresult;
26717 }
26718
26719
26720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26721   int jresult ;
26722   int result;
26723
26724   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26725   jresult = (int)result;
26726   return jresult;
26727 }
26728
26729
26730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26731   int jresult ;
26732   int result;
26733
26734   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26735   jresult = (int)result;
26736   return jresult;
26737 }
26738
26739
26740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26741   int jresult ;
26742   int result;
26743
26744   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26745   jresult = (int)result;
26746   return jresult;
26747 }
26748
26749
26750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26751   int jresult ;
26752   int result;
26753
26754   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26755   jresult = (int)result;
26756   return jresult;
26757 }
26758
26759
26760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26761   int jresult ;
26762   int result;
26763
26764   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26765   jresult = (int)result;
26766   return jresult;
26767 }
26768
26769
26770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26771   void * jresult ;
26772   Dali::Renderer::Property *result = 0 ;
26773
26774   {
26775     try {
26776       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26777     } catch (std::out_of_range& e) {
26778       {
26779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26780       };
26781     } catch (std::exception& e) {
26782       {
26783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26784       };
26785     } catch (Dali::DaliException e) {
26786       {
26787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26788       };
26789     } catch (...) {
26790       {
26791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26792       };
26793     }
26794   }
26795
26796   jresult = (void *)result;
26797   return jresult;
26798 }
26799
26800
26801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26802   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26803
26804   arg1 = (Dali::Renderer::Property *)jarg1;
26805   {
26806     try {
26807       delete arg1;
26808     } catch (std::out_of_range& e) {
26809       {
26810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26811       };
26812     } catch (std::exception& e) {
26813       {
26814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26815       };
26816     } catch (Dali::DaliException e) {
26817       {
26818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26819       };
26820     } catch (...) {
26821       {
26822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26823       };
26824     }
26825   }
26826
26827 }
26828
26829
26830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26831   void * jresult ;
26832   Dali::Geometry *arg1 = 0 ;
26833   Dali::Shader *arg2 = 0 ;
26834   Dali::Renderer result;
26835
26836   arg1 = (Dali::Geometry *)jarg1;
26837   if (!arg1) {
26838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26839     return 0;
26840   }
26841   arg2 = (Dali::Shader *)jarg2;
26842   if (!arg2) {
26843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26844     return 0;
26845   }
26846   {
26847     try {
26848       result = Dali::Renderer::New(*arg1,*arg2);
26849     } catch (std::out_of_range& e) {
26850       {
26851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26852       };
26853     } catch (std::exception& e) {
26854       {
26855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26856       };
26857     } catch (Dali::DaliException e) {
26858       {
26859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26860       };
26861     } catch (...) {
26862       {
26863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26864       };
26865     }
26866   }
26867
26868   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26869   return jresult;
26870 }
26871
26872
26873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26874   void * jresult ;
26875   Dali::Renderer *result = 0 ;
26876
26877   {
26878     try {
26879       result = (Dali::Renderer *)new Dali::Renderer();
26880     } catch (std::out_of_range& e) {
26881       {
26882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26883       };
26884     } catch (std::exception& e) {
26885       {
26886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26887       };
26888     } catch (Dali::DaliException e) {
26889       {
26890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26891       };
26892     } catch (...) {
26893       {
26894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26895       };
26896     }
26897   }
26898
26899   jresult = (void *)result;
26900   return jresult;
26901 }
26902
26903
26904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26905   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26906
26907   arg1 = (Dali::Renderer *)jarg1;
26908   {
26909     try {
26910       delete arg1;
26911     } catch (std::out_of_range& e) {
26912       {
26913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26914       };
26915     } catch (std::exception& e) {
26916       {
26917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26918       };
26919     } catch (Dali::DaliException e) {
26920       {
26921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26922       };
26923     } catch (...) {
26924       {
26925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26926       };
26927     }
26928   }
26929
26930 }
26931
26932
26933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26934   void * jresult ;
26935   Dali::Renderer *arg1 = 0 ;
26936   Dali::Renderer *result = 0 ;
26937
26938   arg1 = (Dali::Renderer *)jarg1;
26939   if (!arg1) {
26940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26941     return 0;
26942   }
26943   {
26944     try {
26945       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26946     } catch (std::out_of_range& e) {
26947       {
26948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26949       };
26950     } catch (std::exception& e) {
26951       {
26952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26953       };
26954     } catch (Dali::DaliException e) {
26955       {
26956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26957       };
26958     } catch (...) {
26959       {
26960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26961       };
26962     }
26963   }
26964
26965   jresult = (void *)result;
26966   return jresult;
26967 }
26968
26969
26970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26971   void * jresult ;
26972   Dali::BaseHandle arg1 ;
26973   Dali::BaseHandle *argp1 ;
26974   Dali::Renderer result;
26975
26976   argp1 = (Dali::BaseHandle *)jarg1;
26977   if (!argp1) {
26978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26979     return 0;
26980   }
26981   arg1 = *argp1;
26982   {
26983     try {
26984       result = Dali::Renderer::DownCast(arg1);
26985     } catch (std::out_of_range& e) {
26986       {
26987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26988       };
26989     } catch (std::exception& e) {
26990       {
26991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26992       };
26993     } catch (Dali::DaliException e) {
26994       {
26995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26996       };
26997     } catch (...) {
26998       {
26999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27000       };
27001     }
27002   }
27003
27004   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27005   return jresult;
27006 }
27007
27008
27009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27010   void * jresult ;
27011   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27012   Dali::Renderer *arg2 = 0 ;
27013   Dali::Renderer *result = 0 ;
27014
27015   arg1 = (Dali::Renderer *)jarg1;
27016   arg2 = (Dali::Renderer *)jarg2;
27017   if (!arg2) {
27018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27019     return 0;
27020   }
27021   {
27022     try {
27023       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27024     } catch (std::out_of_range& e) {
27025       {
27026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27027       };
27028     } catch (std::exception& e) {
27029       {
27030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27031       };
27032     } catch (Dali::DaliException e) {
27033       {
27034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27035       };
27036     } catch (...) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27039       };
27040     }
27041   }
27042
27043   jresult = (void *)result;
27044   return jresult;
27045 }
27046
27047
27048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27049   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27050   Dali::Geometry *arg2 = 0 ;
27051
27052   arg1 = (Dali::Renderer *)jarg1;
27053   arg2 = (Dali::Geometry *)jarg2;
27054   if (!arg2) {
27055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27056     return ;
27057   }
27058   {
27059     try {
27060       (arg1)->SetGeometry(*arg2);
27061     } catch (std::out_of_range& e) {
27062       {
27063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27064       };
27065     } catch (std::exception& e) {
27066       {
27067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27068       };
27069     } catch (Dali::DaliException e) {
27070       {
27071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27072       };
27073     } catch (...) {
27074       {
27075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27076       };
27077     }
27078   }
27079
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27084   void * jresult ;
27085   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27086   Dali::Geometry result;
27087
27088   arg1 = (Dali::Renderer *)jarg1;
27089   {
27090     try {
27091       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27092     } catch (std::out_of_range& e) {
27093       {
27094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (std::exception& e) {
27097       {
27098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27099       };
27100     } catch (Dali::DaliException e) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27103       };
27104     } catch (...) {
27105       {
27106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27107       };
27108     }
27109   }
27110
27111   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27112   return jresult;
27113 }
27114
27115
27116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27117   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27118   int arg2 ;
27119   int arg3 ;
27120
27121   arg1 = (Dali::Renderer *)jarg1;
27122   arg2 = (int)jarg2;
27123   arg3 = (int)jarg3;
27124   {
27125     try {
27126       (arg1)->SetIndexRange(arg2,arg3);
27127     } catch (std::out_of_range& e) {
27128       {
27129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27130       };
27131     } catch (std::exception& e) {
27132       {
27133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27134       };
27135     } catch (Dali::DaliException e) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27138       };
27139     } catch (...) {
27140       {
27141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27142       };
27143     }
27144   }
27145
27146 }
27147
27148
27149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27150   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27151   Dali::TextureSet *arg2 = 0 ;
27152
27153   arg1 = (Dali::Renderer *)jarg1;
27154   arg2 = (Dali::TextureSet *)jarg2;
27155   if (!arg2) {
27156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27157     return ;
27158   }
27159   {
27160     try {
27161       (arg1)->SetTextures(*arg2);
27162     } catch (std::out_of_range& e) {
27163       {
27164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27165       };
27166     } catch (std::exception& e) {
27167       {
27168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27169       };
27170     } catch (Dali::DaliException e) {
27171       {
27172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27173       };
27174     } catch (...) {
27175       {
27176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27177       };
27178     }
27179   }
27180
27181 }
27182
27183
27184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27185   void * jresult ;
27186   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27187   Dali::TextureSet result;
27188
27189   arg1 = (Dali::Renderer *)jarg1;
27190   {
27191     try {
27192       result = ((Dali::Renderer const *)arg1)->GetTextures();
27193     } catch (std::out_of_range& e) {
27194       {
27195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (std::exception& e) {
27198       {
27199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27200       };
27201     } catch (Dali::DaliException e) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27204       };
27205     } catch (...) {
27206       {
27207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27208       };
27209     }
27210   }
27211
27212   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27213   return jresult;
27214 }
27215
27216
27217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27218   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27219   Dali::Shader *arg2 = 0 ;
27220
27221   arg1 = (Dali::Renderer *)jarg1;
27222   arg2 = (Dali::Shader *)jarg2;
27223   if (!arg2) {
27224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27225     return ;
27226   }
27227   {
27228     try {
27229       (arg1)->SetShader(*arg2);
27230     } catch (std::out_of_range& e) {
27231       {
27232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27233       };
27234     } catch (std::exception& e) {
27235       {
27236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27237       };
27238     } catch (Dali::DaliException e) {
27239       {
27240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27241       };
27242     } catch (...) {
27243       {
27244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27245       };
27246     }
27247   }
27248
27249 }
27250
27251
27252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27253   void * jresult ;
27254   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27255   Dali::Shader result;
27256
27257   arg1 = (Dali::Renderer *)jarg1;
27258   {
27259     try {
27260       result = ((Dali::Renderer const *)arg1)->GetShader();
27261     } catch (std::out_of_range& e) {
27262       {
27263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27264       };
27265     } catch (std::exception& e) {
27266       {
27267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27268       };
27269     } catch (Dali::DaliException e) {
27270       {
27271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27272       };
27273     } catch (...) {
27274       {
27275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27276       };
27277     }
27278   }
27279
27280   jresult = new Dali::Shader((const Dali::Shader &)result);
27281   return jresult;
27282 }
27283
27284
27285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27286   void * jresult ;
27287   Dali::FrameBuffer::Attachment *result = 0 ;
27288
27289   {
27290     try {
27291       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27292     } catch (std::out_of_range& e) {
27293       {
27294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27295       };
27296     } catch (std::exception& e) {
27297       {
27298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27299       };
27300     } catch (Dali::DaliException e) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27303       };
27304     } catch (...) {
27305       {
27306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27307       };
27308     }
27309   }
27310
27311   jresult = (void *)result;
27312   return jresult;
27313 }
27314
27315
27316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27317   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27318
27319   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27320   {
27321     try {
27322       delete arg1;
27323     } catch (std::out_of_range& e) {
27324       {
27325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27326       };
27327     } catch (std::exception& e) {
27328       {
27329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27330       };
27331     } catch (Dali::DaliException e) {
27332       {
27333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27334       };
27335     } catch (...) {
27336       {
27337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27338       };
27339     }
27340   }
27341
27342 }
27343
27344
27345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27346   void * jresult ;
27347   unsigned int arg1 ;
27348   unsigned int arg2 ;
27349   unsigned int arg3 ;
27350   Dali::FrameBuffer result;
27351
27352   arg1 = (unsigned int)jarg1;
27353   arg2 = (unsigned int)jarg2;
27354   arg3 = (unsigned int)jarg3;
27355   {
27356     try {
27357       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27358     } catch (std::out_of_range& e) {
27359       {
27360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27361       };
27362     } catch (std::exception& e) {
27363       {
27364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27365       };
27366     } catch (Dali::DaliException e) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27369       };
27370     } catch (...) {
27371       {
27372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27373       };
27374     }
27375   }
27376
27377   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27378   return jresult;
27379 }
27380
27381
27382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27383   void * jresult ;
27384   Dali::FrameBuffer *result = 0 ;
27385
27386   {
27387     try {
27388       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27389     } catch (std::out_of_range& e) {
27390       {
27391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27392       };
27393     } catch (std::exception& e) {
27394       {
27395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27396       };
27397     } catch (Dali::DaliException e) {
27398       {
27399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27400       };
27401     } catch (...) {
27402       {
27403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27404       };
27405     }
27406   }
27407
27408   jresult = (void *)result;
27409   return jresult;
27410 }
27411
27412
27413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27414   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27415
27416   arg1 = (Dali::FrameBuffer *)jarg1;
27417   {
27418     try {
27419       delete arg1;
27420     } catch (std::out_of_range& e) {
27421       {
27422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27423       };
27424     } catch (std::exception& e) {
27425       {
27426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27427       };
27428     } catch (Dali::DaliException e) {
27429       {
27430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27431       };
27432     } catch (...) {
27433       {
27434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27435       };
27436     }
27437   }
27438
27439 }
27440
27441
27442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27443   void * jresult ;
27444   Dali::FrameBuffer *arg1 = 0 ;
27445   Dali::FrameBuffer *result = 0 ;
27446
27447   arg1 = (Dali::FrameBuffer *)jarg1;
27448   if (!arg1) {
27449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27450     return 0;
27451   }
27452   {
27453     try {
27454       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27455     } catch (std::out_of_range& e) {
27456       {
27457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27458       };
27459     } catch (std::exception& e) {
27460       {
27461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27462       };
27463     } catch (Dali::DaliException e) {
27464       {
27465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27466       };
27467     } catch (...) {
27468       {
27469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27470       };
27471     }
27472   }
27473
27474   jresult = (void *)result;
27475   return jresult;
27476 }
27477
27478
27479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27480   void * jresult ;
27481   Dali::BaseHandle arg1 ;
27482   Dali::BaseHandle *argp1 ;
27483   Dali::FrameBuffer result;
27484
27485   argp1 = (Dali::BaseHandle *)jarg1;
27486   if (!argp1) {
27487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27488     return 0;
27489   }
27490   arg1 = *argp1;
27491   {
27492     try {
27493       result = Dali::FrameBuffer::DownCast(arg1);
27494     } catch (std::out_of_range& e) {
27495       {
27496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27497       };
27498     } catch (std::exception& e) {
27499       {
27500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27501       };
27502     } catch (Dali::DaliException e) {
27503       {
27504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27505       };
27506     } catch (...) {
27507       {
27508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27509       };
27510     }
27511   }
27512
27513   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27514   return jresult;
27515 }
27516
27517
27518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27519   void * jresult ;
27520   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27521   Dali::FrameBuffer *arg2 = 0 ;
27522   Dali::FrameBuffer *result = 0 ;
27523
27524   arg1 = (Dali::FrameBuffer *)jarg1;
27525   arg2 = (Dali::FrameBuffer *)jarg2;
27526   if (!arg2) {
27527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27528     return 0;
27529   }
27530   {
27531     try {
27532       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27533     } catch (std::out_of_range& e) {
27534       {
27535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27536       };
27537     } catch (std::exception& e) {
27538       {
27539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27540       };
27541     } catch (Dali::DaliException e) {
27542       {
27543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27544       };
27545     } catch (...) {
27546       {
27547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27548       };
27549     }
27550   }
27551
27552   jresult = (void *)result;
27553   return jresult;
27554 }
27555
27556
27557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27558   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27559   Dali::Texture *arg2 = 0 ;
27560
27561   arg1 = (Dali::FrameBuffer *)jarg1;
27562   arg2 = (Dali::Texture *)jarg2;
27563   if (!arg2) {
27564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27565     return ;
27566   }
27567   {
27568     try {
27569       (arg1)->AttachColorTexture(*arg2);
27570     } catch (std::out_of_range& e) {
27571       {
27572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27573       };
27574     } catch (std::exception& e) {
27575       {
27576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27577       };
27578     } catch (Dali::DaliException e) {
27579       {
27580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27581       };
27582     } catch (...) {
27583       {
27584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27585       };
27586     }
27587   }
27588
27589 }
27590
27591
27592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27593   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27594   Dali::Texture *arg2 = 0 ;
27595   unsigned int arg3 ;
27596   unsigned int arg4 ;
27597
27598   arg1 = (Dali::FrameBuffer *)jarg1;
27599   arg2 = (Dali::Texture *)jarg2;
27600   if (!arg2) {
27601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27602     return ;
27603   }
27604   arg3 = (unsigned int)jarg3;
27605   arg4 = (unsigned int)jarg4;
27606   {
27607     try {
27608       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27609     } catch (std::out_of_range& e) {
27610       {
27611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27612       };
27613     } catch (std::exception& e) {
27614       {
27615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27616       };
27617     } catch (Dali::DaliException e) {
27618       {
27619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27620       };
27621     } catch (...) {
27622       {
27623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27624       };
27625     }
27626   }
27627
27628 }
27629
27630
27631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27632   void * jresult ;
27633   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27634   Dali::Texture result;
27635
27636   arg1 = (Dali::FrameBuffer *)jarg1;
27637   {
27638     try {
27639       result = (arg1)->GetColorTexture();
27640     } catch (std::out_of_range& e) {
27641       {
27642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27643       };
27644     } catch (std::exception& e) {
27645       {
27646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27647       };
27648     } catch (Dali::DaliException e) {
27649       {
27650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27651       };
27652     } catch (...) {
27653       {
27654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27655       };
27656     }
27657   }
27658
27659   jresult = new Dali::Texture((const Dali::Texture &)result);
27660   return jresult;
27661 }
27662
27663
27664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27665   void * jresult ;
27666   Dali::RenderTaskList *result = 0 ;
27667
27668   {
27669     try {
27670       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27671     } catch (std::out_of_range& e) {
27672       {
27673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27674       };
27675     } catch (std::exception& e) {
27676       {
27677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27678       };
27679     } catch (Dali::DaliException e) {
27680       {
27681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27682       };
27683     } catch (...) {
27684       {
27685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27686       };
27687     }
27688   }
27689
27690   jresult = (void *)result;
27691   return jresult;
27692 }
27693
27694
27695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27696   void * jresult ;
27697   Dali::BaseHandle arg1 ;
27698   Dali::BaseHandle *argp1 ;
27699   Dali::RenderTaskList result;
27700
27701   argp1 = (Dali::BaseHandle *)jarg1;
27702   if (!argp1) {
27703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27704     return 0;
27705   }
27706   arg1 = *argp1;
27707   {
27708     try {
27709       result = Dali::RenderTaskList::DownCast(arg1);
27710     } catch (std::out_of_range& e) {
27711       {
27712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27713       };
27714     } catch (std::exception& e) {
27715       {
27716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27717       };
27718     } catch (Dali::DaliException e) {
27719       {
27720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27721       };
27722     } catch (...) {
27723       {
27724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27725       };
27726     }
27727   }
27728
27729   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27730   return jresult;
27731 }
27732
27733
27734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27735   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27736
27737   arg1 = (Dali::RenderTaskList *)jarg1;
27738   {
27739     try {
27740       delete arg1;
27741     } catch (std::out_of_range& e) {
27742       {
27743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27744       };
27745     } catch (std::exception& e) {
27746       {
27747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27748       };
27749     } catch (Dali::DaliException e) {
27750       {
27751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27752       };
27753     } catch (...) {
27754       {
27755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27756       };
27757     }
27758   }
27759
27760 }
27761
27762
27763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27764   void * jresult ;
27765   Dali::RenderTaskList *arg1 = 0 ;
27766   Dali::RenderTaskList *result = 0 ;
27767
27768   arg1 = (Dali::RenderTaskList *)jarg1;
27769   if (!arg1) {
27770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27771     return 0;
27772   }
27773   {
27774     try {
27775       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27776     } catch (std::out_of_range& e) {
27777       {
27778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27779       };
27780     } catch (std::exception& e) {
27781       {
27782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27783       };
27784     } catch (Dali::DaliException e) {
27785       {
27786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27787       };
27788     } catch (...) {
27789       {
27790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27791       };
27792     }
27793   }
27794
27795   jresult = (void *)result;
27796   return jresult;
27797 }
27798
27799
27800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27801   void * jresult ;
27802   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27803   Dali::RenderTaskList *arg2 = 0 ;
27804   Dali::RenderTaskList *result = 0 ;
27805
27806   arg1 = (Dali::RenderTaskList *)jarg1;
27807   arg2 = (Dali::RenderTaskList *)jarg2;
27808   if (!arg2) {
27809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27810     return 0;
27811   }
27812   {
27813     try {
27814       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27815     } catch (std::out_of_range& e) {
27816       {
27817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27818       };
27819     } catch (std::exception& e) {
27820       {
27821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27822       };
27823     } catch (Dali::DaliException e) {
27824       {
27825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27826       };
27827     } catch (...) {
27828       {
27829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27830       };
27831     }
27832   }
27833
27834   jresult = (void *)result;
27835   return jresult;
27836 }
27837
27838
27839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27840   void * jresult ;
27841   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27842   Dali::RenderTask result;
27843
27844   arg1 = (Dali::RenderTaskList *)jarg1;
27845   {
27846     try {
27847       result = (arg1)->CreateTask();
27848     } catch (std::out_of_range& e) {
27849       {
27850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27851       };
27852     } catch (std::exception& e) {
27853       {
27854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27855       };
27856     } catch (Dali::DaliException e) {
27857       {
27858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27859       };
27860     } catch (...) {
27861       {
27862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27863       };
27864     }
27865   }
27866
27867   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27868   return jresult;
27869 }
27870
27871
27872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27873   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27874   Dali::RenderTask arg2 ;
27875   Dali::RenderTask *argp2 ;
27876
27877   arg1 = (Dali::RenderTaskList *)jarg1;
27878   argp2 = (Dali::RenderTask *)jarg2;
27879   if (!argp2) {
27880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27881     return ;
27882   }
27883   arg2 = *argp2;
27884   {
27885     try {
27886       (arg1)->RemoveTask(arg2);
27887     } catch (std::out_of_range& e) {
27888       {
27889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27890       };
27891     } catch (std::exception& e) {
27892       {
27893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27894       };
27895     } catch (Dali::DaliException e) {
27896       {
27897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27898       };
27899     } catch (...) {
27900       {
27901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27902       };
27903     }
27904   }
27905
27906 }
27907
27908
27909 //// ===============================================end part 1 =================
27910
27911 //// ========================= part 2 ===============================
27912
27913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27914   unsigned int jresult ;
27915   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27916   unsigned int result;
27917
27918   arg1 = (Dali::RenderTaskList *)jarg1;
27919   {
27920     try {
27921       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27922     } catch (std::out_of_range& e) {
27923       {
27924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27925       };
27926     } catch (std::exception& e) {
27927       {
27928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27929       };
27930     } catch (Dali::DaliException e) {
27931       {
27932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27933       };
27934     } catch (...) {
27935       {
27936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27937       };
27938     }
27939   }
27940
27941   jresult = result;
27942   return jresult;
27943 }
27944
27945
27946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27947   void * jresult ;
27948   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27949   unsigned int arg2 ;
27950   Dali::RenderTask result;
27951
27952   arg1 = (Dali::RenderTaskList *)jarg1;
27953   arg2 = (unsigned int)jarg2;
27954   {
27955     try {
27956       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27957     } catch (std::out_of_range& e) {
27958       {
27959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (std::exception& e) {
27962       {
27963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27964       };
27965     } catch (Dali::DaliException e) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27968       };
27969     } catch (...) {
27970       {
27971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27972       };
27973     }
27974   }
27975
27976   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27977   return jresult;
27978 }
27979
27980
27981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27982   int jresult ;
27983   int result;
27984
27985   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27986   jresult = (int)result;
27987   return jresult;
27988 }
27989
27990
27991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27992   int jresult ;
27993   int result;
27994
27995   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27996   jresult = (int)result;
27997   return jresult;
27998 }
27999
28000
28001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28002   int jresult ;
28003   int result;
28004
28005   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28006   jresult = (int)result;
28007   return jresult;
28008 }
28009
28010
28011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28012   int jresult ;
28013   int result;
28014
28015   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28016   jresult = (int)result;
28017   return jresult;
28018 }
28019
28020
28021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28022   void * jresult ;
28023   Dali::RenderTask::Property *result = 0 ;
28024
28025   {
28026     try {
28027       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28028     } catch (std::out_of_range& e) {
28029       {
28030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28031       };
28032     } catch (std::exception& e) {
28033       {
28034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28035       };
28036     } catch (Dali::DaliException e) {
28037       {
28038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28039       };
28040     } catch (...) {
28041       {
28042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28043       };
28044     }
28045   }
28046
28047   jresult = (void *)result;
28048   return jresult;
28049 }
28050
28051
28052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28053   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28054
28055   arg1 = (Dali::RenderTask::Property *)jarg1;
28056   {
28057     try {
28058       delete arg1;
28059     } catch (std::out_of_range& e) {
28060       {
28061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28062       };
28063     } catch (std::exception& e) {
28064       {
28065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28066       };
28067     } catch (Dali::DaliException e) {
28068       {
28069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28070       };
28071     } catch (...) {
28072       {
28073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28074       };
28075     }
28076   }
28077
28078 }
28079
28080
28081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28082   void * jresult ;
28083   bool (*result)(Dali::Vector2 &) = 0 ;
28084
28085   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28086   jresult = (void *)result;
28087   return jresult;
28088 }
28089
28090
28091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28092   void * jresult ;
28093   bool (*result)(Dali::Vector2 &) = 0 ;
28094
28095   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28096   jresult = (void *)result;
28097   return jresult;
28098 }
28099
28100
28101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28102   unsigned int jresult ;
28103   bool result;
28104
28105   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28106   jresult = result;
28107   return jresult;
28108 }
28109
28110
28111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28112   unsigned int jresult ;
28113   bool result;
28114
28115   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28116   jresult = result;
28117   return jresult;
28118 }
28119
28120
28121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28122   void * jresult ;
28123   Dali::Vector4 *result = 0 ;
28124
28125   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28126   jresult = (void *)result;
28127   return jresult;
28128 }
28129
28130
28131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28132   unsigned int jresult ;
28133   bool result;
28134
28135   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28136   jresult = result;
28137   return jresult;
28138 }
28139
28140
28141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28142   unsigned int jresult ;
28143   bool result;
28144
28145   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28146   jresult = result;
28147   return jresult;
28148 }
28149
28150
28151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28152   unsigned int jresult ;
28153   unsigned int result;
28154
28155   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28156   jresult = result;
28157   return jresult;
28158 }
28159
28160
28161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28162   void * jresult ;
28163   Dali::RenderTask *result = 0 ;
28164
28165   {
28166     try {
28167       result = (Dali::RenderTask *)new Dali::RenderTask();
28168     } catch (std::out_of_range& e) {
28169       {
28170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28171       };
28172     } catch (std::exception& e) {
28173       {
28174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28175       };
28176     } catch (Dali::DaliException e) {
28177       {
28178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28179       };
28180     } catch (...) {
28181       {
28182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28183       };
28184     }
28185   }
28186
28187   jresult = (void *)result;
28188   return jresult;
28189 }
28190
28191
28192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28193   void * jresult ;
28194   Dali::BaseHandle arg1 ;
28195   Dali::BaseHandle *argp1 ;
28196   Dali::RenderTask result;
28197
28198   argp1 = (Dali::BaseHandle *)jarg1;
28199   if (!argp1) {
28200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28201     return 0;
28202   }
28203   arg1 = *argp1;
28204   {
28205     try {
28206       result = Dali::RenderTask::DownCast(arg1);
28207     } catch (std::out_of_range& e) {
28208       {
28209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28210       };
28211     } catch (std::exception& e) {
28212       {
28213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28214       };
28215     } catch (Dali::DaliException e) {
28216       {
28217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28218       };
28219     } catch (...) {
28220       {
28221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28222       };
28223     }
28224   }
28225
28226   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28227   return jresult;
28228 }
28229
28230
28231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28232   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28233
28234   arg1 = (Dali::RenderTask *)jarg1;
28235   {
28236     try {
28237       delete arg1;
28238     } catch (std::out_of_range& e) {
28239       {
28240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28241       };
28242     } catch (std::exception& e) {
28243       {
28244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28245       };
28246     } catch (Dali::DaliException e) {
28247       {
28248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28249       };
28250     } catch (...) {
28251       {
28252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28253       };
28254     }
28255   }
28256
28257 }
28258
28259
28260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28261   void * jresult ;
28262   Dali::RenderTask *arg1 = 0 ;
28263   Dali::RenderTask *result = 0 ;
28264
28265   arg1 = (Dali::RenderTask *)jarg1;
28266   if (!arg1) {
28267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28268     return 0;
28269   }
28270   {
28271     try {
28272       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28273     } catch (std::out_of_range& e) {
28274       {
28275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28276       };
28277     } catch (std::exception& e) {
28278       {
28279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28280       };
28281     } catch (Dali::DaliException e) {
28282       {
28283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28284       };
28285     } catch (...) {
28286       {
28287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28288       };
28289     }
28290   }
28291
28292   jresult = (void *)result;
28293   return jresult;
28294 }
28295
28296
28297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28298   void * jresult ;
28299   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28300   Dali::RenderTask *arg2 = 0 ;
28301   Dali::RenderTask *result = 0 ;
28302
28303   arg1 = (Dali::RenderTask *)jarg1;
28304   arg2 = (Dali::RenderTask *)jarg2;
28305   if (!arg2) {
28306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28307     return 0;
28308   }
28309   {
28310     try {
28311       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28312     } catch (std::out_of_range& e) {
28313       {
28314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28315       };
28316     } catch (std::exception& e) {
28317       {
28318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28319       };
28320     } catch (Dali::DaliException e) {
28321       {
28322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28323       };
28324     } catch (...) {
28325       {
28326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28327       };
28328     }
28329   }
28330
28331   jresult = (void *)result;
28332   return jresult;
28333 }
28334
28335
28336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28337   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28338   Dali::Actor arg2 ;
28339   Dali::Actor *argp2 ;
28340
28341   arg1 = (Dali::RenderTask *)jarg1;
28342   argp2 = (Dali::Actor *)jarg2;
28343   if (!argp2) {
28344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28345     return ;
28346   }
28347   arg2 = *argp2;
28348   {
28349     try {
28350       (arg1)->SetSourceActor(arg2);
28351     } catch (std::out_of_range& e) {
28352       {
28353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28354       };
28355     } catch (std::exception& e) {
28356       {
28357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28358       };
28359     } catch (Dali::DaliException e) {
28360       {
28361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28362       };
28363     } catch (...) {
28364       {
28365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28366       };
28367     }
28368   }
28369
28370 }
28371
28372
28373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28374   void * jresult ;
28375   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28376   Dali::Actor result;
28377
28378   arg1 = (Dali::RenderTask *)jarg1;
28379   {
28380     try {
28381       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28382     } catch (std::out_of_range& e) {
28383       {
28384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28385       };
28386     } catch (std::exception& e) {
28387       {
28388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28389       };
28390     } catch (Dali::DaliException e) {
28391       {
28392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28393       };
28394     } catch (...) {
28395       {
28396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28397       };
28398     }
28399   }
28400
28401   jresult = new Dali::Actor((const Dali::Actor &)result);
28402   return jresult;
28403 }
28404
28405
28406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28407   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28408   bool arg2 ;
28409
28410   arg1 = (Dali::RenderTask *)jarg1;
28411   arg2 = jarg2 ? true : false;
28412   {
28413     try {
28414       (arg1)->SetExclusive(arg2);
28415     } catch (std::out_of_range& e) {
28416       {
28417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28418       };
28419     } catch (std::exception& e) {
28420       {
28421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28422       };
28423     } catch (Dali::DaliException e) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28426       };
28427     } catch (...) {
28428       {
28429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28430       };
28431     }
28432   }
28433
28434 }
28435
28436
28437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28438   unsigned int jresult ;
28439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28440   bool result;
28441
28442   arg1 = (Dali::RenderTask *)jarg1;
28443   {
28444     try {
28445       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28446     } catch (std::out_of_range& e) {
28447       {
28448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28449       };
28450     } catch (std::exception& e) {
28451       {
28452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28453       };
28454     } catch (Dali::DaliException e) {
28455       {
28456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28457       };
28458     } catch (...) {
28459       {
28460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28461       };
28462     }
28463   }
28464
28465   jresult = result;
28466   return jresult;
28467 }
28468
28469
28470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28471   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28472   bool arg2 ;
28473
28474   arg1 = (Dali::RenderTask *)jarg1;
28475   arg2 = jarg2 ? true : false;
28476   {
28477     try {
28478       (arg1)->SetInputEnabled(arg2);
28479     } catch (std::out_of_range& e) {
28480       {
28481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (std::exception& e) {
28484       {
28485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28486       };
28487     } catch (Dali::DaliException e) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28490       };
28491     } catch (...) {
28492       {
28493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28494       };
28495     }
28496   }
28497
28498 }
28499
28500
28501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28502   unsigned int jresult ;
28503   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28504   bool result;
28505
28506   arg1 = (Dali::RenderTask *)jarg1;
28507   {
28508     try {
28509       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28510     } catch (std::out_of_range& e) {
28511       {
28512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (std::exception& e) {
28515       {
28516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28517       };
28518     } catch (Dali::DaliException e) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28521       };
28522     } catch (...) {
28523       {
28524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28525       };
28526     }
28527   }
28528
28529   jresult = result;
28530   return jresult;
28531 }
28532
28533
28534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28535   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28536   Dali::CameraActor arg2 ;
28537   Dali::CameraActor *argp2 ;
28538
28539   arg1 = (Dali::RenderTask *)jarg1;
28540   argp2 = (Dali::CameraActor *)jarg2;
28541   if (!argp2) {
28542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28543     return ;
28544   }
28545   arg2 = *argp2;
28546   {
28547     try {
28548       (arg1)->SetCameraActor(arg2);
28549     } catch (std::out_of_range& e) {
28550       {
28551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28552       };
28553     } catch (std::exception& e) {
28554       {
28555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28556       };
28557     } catch (Dali::DaliException e) {
28558       {
28559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28560       };
28561     } catch (...) {
28562       {
28563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28564       };
28565     }
28566   }
28567
28568 }
28569
28570
28571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28572   void * jresult ;
28573   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28574   Dali::CameraActor result;
28575
28576   arg1 = (Dali::RenderTask *)jarg1;
28577   {
28578     try {
28579       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28580     } catch (std::out_of_range& e) {
28581       {
28582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28583       };
28584     } catch (std::exception& e) {
28585       {
28586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28587       };
28588     } catch (Dali::DaliException e) {
28589       {
28590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28591       };
28592     } catch (...) {
28593       {
28594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28595       };
28596     }
28597   }
28598
28599   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28600   return jresult;
28601 }
28602
28603
28604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28605   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28606   Dali::FrameBufferImage arg2 ;
28607   Dali::FrameBufferImage *argp2 ;
28608
28609   arg1 = (Dali::RenderTask *)jarg1;
28610   argp2 = (Dali::FrameBufferImage *)jarg2;
28611   if (!argp2) {
28612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28613     return ;
28614   }
28615   arg2 = *argp2;
28616   {
28617     try {
28618       (arg1)->SetTargetFrameBuffer(arg2);
28619     } catch (std::out_of_range& e) {
28620       {
28621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28622       };
28623     } catch (std::exception& e) {
28624       {
28625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28626       };
28627     } catch (Dali::DaliException e) {
28628       {
28629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28630       };
28631     } catch (...) {
28632       {
28633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28634       };
28635     }
28636   }
28637
28638 }
28639
28640
28641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28642   void * jresult ;
28643   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28644   Dali::FrameBufferImage result;
28645
28646   arg1 = (Dali::RenderTask *)jarg1;
28647   {
28648     try {
28649       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28650     } catch (std::out_of_range& e) {
28651       {
28652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28653       };
28654     } catch (std::exception& e) {
28655       {
28656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28657       };
28658     } catch (Dali::DaliException e) {
28659       {
28660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28661       };
28662     } catch (...) {
28663       {
28664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28665       };
28666     }
28667   }
28668
28669   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28670   return jresult;
28671 }
28672
28673
28674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28675   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28676   Dali::FrameBuffer arg2 ;
28677   Dali::FrameBuffer *argp2 ;
28678
28679   arg1 = (Dali::RenderTask *)jarg1;
28680   argp2 = (Dali::FrameBuffer *)jarg2;
28681   if (!argp2) {
28682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28683     return ;
28684   }
28685   arg2 = *argp2;
28686   {
28687     try {
28688       (arg1)->SetFrameBuffer(arg2);
28689     } catch (std::out_of_range& e) {
28690       {
28691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28692       };
28693     } catch (std::exception& e) {
28694       {
28695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28696       };
28697     } catch (Dali::DaliException e) {
28698       {
28699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28700       };
28701     } catch (...) {
28702       {
28703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28704       };
28705     }
28706   }
28707
28708 }
28709
28710
28711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28712   void * jresult ;
28713   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28714   Dali::FrameBuffer result;
28715
28716   arg1 = (Dali::RenderTask *)jarg1;
28717   {
28718     try {
28719       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28720     } catch (std::out_of_range& e) {
28721       {
28722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28723       };
28724     } catch (std::exception& e) {
28725       {
28726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28727       };
28728     } catch (Dali::DaliException e) {
28729       {
28730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28731       };
28732     } catch (...) {
28733       {
28734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28735       };
28736     }
28737   }
28738
28739   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28745   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28746   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28747
28748   arg1 = (Dali::RenderTask *)jarg1;
28749   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28750   {
28751     try {
28752       (arg1)->SetScreenToFrameBufferFunction(arg2);
28753     } catch (std::out_of_range& e) {
28754       {
28755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28756       };
28757     } catch (std::exception& e) {
28758       {
28759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28760       };
28761     } catch (Dali::DaliException e) {
28762       {
28763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28764       };
28765     } catch (...) {
28766       {
28767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28768       };
28769     }
28770   }
28771
28772 }
28773
28774
28775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28776   void * jresult ;
28777   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28778   Dali::RenderTask::ScreenToFrameBufferFunction result;
28779
28780   arg1 = (Dali::RenderTask *)jarg1;
28781   {
28782     try {
28783       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28784     } catch (std::out_of_range& e) {
28785       {
28786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28787       };
28788     } catch (std::exception& e) {
28789       {
28790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28791       };
28792     } catch (Dali::DaliException e) {
28793       {
28794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28795       };
28796     } catch (...) {
28797       {
28798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28799       };
28800     }
28801   }
28802
28803   jresult = (void *)result;
28804   return jresult;
28805 }
28806
28807
28808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28809   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28810   Dali::Actor arg2 ;
28811   Dali::Actor *argp2 ;
28812
28813   arg1 = (Dali::RenderTask *)jarg1;
28814   argp2 = (Dali::Actor *)jarg2;
28815   if (!argp2) {
28816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28817     return ;
28818   }
28819   arg2 = *argp2;
28820   {
28821     try {
28822       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28823     } catch (std::out_of_range& e) {
28824       {
28825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28826       };
28827     } catch (std::exception& e) {
28828       {
28829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28830       };
28831     } catch (Dali::DaliException e) {
28832       {
28833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28834       };
28835     } catch (...) {
28836       {
28837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28838       };
28839     }
28840   }
28841
28842 }
28843
28844
28845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28846   void * jresult ;
28847   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28848   Dali::Actor result;
28849
28850   arg1 = (Dali::RenderTask *)jarg1;
28851   {
28852     try {
28853       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28854     } catch (std::out_of_range& e) {
28855       {
28856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28857       };
28858     } catch (std::exception& e) {
28859       {
28860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28861       };
28862     } catch (Dali::DaliException e) {
28863       {
28864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28865       };
28866     } catch (...) {
28867       {
28868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28869       };
28870     }
28871   }
28872
28873   jresult = new Dali::Actor((const Dali::Actor &)result);
28874   return jresult;
28875 }
28876
28877
28878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28879   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28880   Dali::Vector2 arg2 ;
28881   Dali::Vector2 *argp2 ;
28882
28883   arg1 = (Dali::RenderTask *)jarg1;
28884   argp2 = (Dali::Vector2 *)jarg2;
28885   if (!argp2) {
28886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28887     return ;
28888   }
28889   arg2 = *argp2;
28890   {
28891     try {
28892       (arg1)->SetViewportPosition(arg2);
28893     } catch (std::out_of_range& e) {
28894       {
28895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28896       };
28897     } catch (std::exception& e) {
28898       {
28899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28900       };
28901     } catch (Dali::DaliException e) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28904       };
28905     } catch (...) {
28906       {
28907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28908       };
28909     }
28910   }
28911
28912 }
28913
28914
28915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28916   void * jresult ;
28917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28918   Dali::Vector2 result;
28919
28920   arg1 = (Dali::RenderTask *)jarg1;
28921   {
28922     try {
28923       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28924     } catch (std::out_of_range& e) {
28925       {
28926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28927       };
28928     } catch (std::exception& e) {
28929       {
28930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28931       };
28932     } catch (Dali::DaliException e) {
28933       {
28934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28935       };
28936     } catch (...) {
28937       {
28938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28939       };
28940     }
28941   }
28942
28943   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28944   return jresult;
28945 }
28946
28947
28948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28949   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28950   Dali::Vector2 arg2 ;
28951   Dali::Vector2 *argp2 ;
28952
28953   arg1 = (Dali::RenderTask *)jarg1;
28954   argp2 = (Dali::Vector2 *)jarg2;
28955   if (!argp2) {
28956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28957     return ;
28958   }
28959   arg2 = *argp2;
28960   {
28961     try {
28962       (arg1)->SetViewportSize(arg2);
28963     } catch (std::out_of_range& e) {
28964       {
28965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28966       };
28967     } catch (std::exception& e) {
28968       {
28969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28970       };
28971     } catch (Dali::DaliException e) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28974       };
28975     } catch (...) {
28976       {
28977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28978       };
28979     }
28980   }
28981
28982 }
28983
28984
28985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28986   void * jresult ;
28987   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28988   Dali::Vector2 result;
28989
28990   arg1 = (Dali::RenderTask *)jarg1;
28991   {
28992     try {
28993       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28994     } catch (std::out_of_range& e) {
28995       {
28996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28997       };
28998     } catch (std::exception& e) {
28999       {
29000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29001       };
29002     } catch (Dali::DaliException e) {
29003       {
29004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29005       };
29006     } catch (...) {
29007       {
29008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29009       };
29010     }
29011   }
29012
29013   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29014   return jresult;
29015 }
29016
29017
29018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29019   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29020   Dali::Viewport arg2 ;
29021   Dali::Viewport *argp2 ;
29022
29023   arg1 = (Dali::RenderTask *)jarg1;
29024   argp2 = (Dali::Viewport *)jarg2;
29025   if (!argp2) {
29026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29027     return ;
29028   }
29029   arg2 = *argp2;
29030   {
29031     try {
29032       (arg1)->SetViewport(arg2);
29033     } catch (std::out_of_range& e) {
29034       {
29035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29036       };
29037     } catch (std::exception& e) {
29038       {
29039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29040       };
29041     } catch (Dali::DaliException e) {
29042       {
29043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29044       };
29045     } catch (...) {
29046       {
29047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29048       };
29049     }
29050   }
29051
29052 }
29053
29054
29055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29056   void * jresult ;
29057   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29058   Dali::Viewport result;
29059
29060   arg1 = (Dali::RenderTask *)jarg1;
29061   {
29062     try {
29063       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29064     } catch (std::out_of_range& e) {
29065       {
29066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29067       };
29068     } catch (std::exception& e) {
29069       {
29070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29071       };
29072     } catch (Dali::DaliException e) {
29073       {
29074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29075       };
29076     } catch (...) {
29077       {
29078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29079       };
29080     }
29081   }
29082
29083   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29084   return jresult;
29085 }
29086
29087
29088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29089   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29090   Dali::Vector4 *arg2 = 0 ;
29091
29092   arg1 = (Dali::RenderTask *)jarg1;
29093   arg2 = (Dali::Vector4 *)jarg2;
29094   if (!arg2) {
29095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29096     return ;
29097   }
29098   {
29099     try {
29100       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29101     } catch (std::out_of_range& e) {
29102       {
29103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29104       };
29105     } catch (std::exception& e) {
29106       {
29107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29108       };
29109     } catch (Dali::DaliException e) {
29110       {
29111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29112       };
29113     } catch (...) {
29114       {
29115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29116       };
29117     }
29118   }
29119
29120 }
29121
29122
29123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29124   void * jresult ;
29125   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29126   Dali::Vector4 result;
29127
29128   arg1 = (Dali::RenderTask *)jarg1;
29129   {
29130     try {
29131       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29132     } catch (std::out_of_range& e) {
29133       {
29134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29135       };
29136     } catch (std::exception& e) {
29137       {
29138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29139       };
29140     } catch (Dali::DaliException e) {
29141       {
29142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29143       };
29144     } catch (...) {
29145       {
29146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29147       };
29148     }
29149   }
29150
29151   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29152   return jresult;
29153 }
29154
29155
29156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29157   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29158   bool arg2 ;
29159
29160   arg1 = (Dali::RenderTask *)jarg1;
29161   arg2 = jarg2 ? true : false;
29162   {
29163     try {
29164       (arg1)->SetClearEnabled(arg2);
29165     } catch (std::out_of_range& e) {
29166       {
29167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29168       };
29169     } catch (std::exception& e) {
29170       {
29171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29172       };
29173     } catch (Dali::DaliException e) {
29174       {
29175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29176       };
29177     } catch (...) {
29178       {
29179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29180       };
29181     }
29182   }
29183
29184 }
29185
29186
29187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29188   unsigned int jresult ;
29189   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29190   bool result;
29191
29192   arg1 = (Dali::RenderTask *)jarg1;
29193   {
29194     try {
29195       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29196     } catch (std::out_of_range& e) {
29197       {
29198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29199       };
29200     } catch (std::exception& e) {
29201       {
29202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29203       };
29204     } catch (Dali::DaliException e) {
29205       {
29206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29207       };
29208     } catch (...) {
29209       {
29210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29211       };
29212     }
29213   }
29214
29215   jresult = result;
29216   return jresult;
29217 }
29218
29219
29220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29221   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29222   bool arg2 ;
29223
29224   arg1 = (Dali::RenderTask *)jarg1;
29225   arg2 = jarg2 ? true : false;
29226   {
29227     try {
29228       (arg1)->SetCullMode(arg2);
29229     } catch (std::out_of_range& e) {
29230       {
29231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29232       };
29233     } catch (std::exception& e) {
29234       {
29235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29236       };
29237     } catch (Dali::DaliException e) {
29238       {
29239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29240       };
29241     } catch (...) {
29242       {
29243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29244       };
29245     }
29246   }
29247
29248 }
29249
29250
29251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29252   unsigned int jresult ;
29253   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29254   bool result;
29255
29256   arg1 = (Dali::RenderTask *)jarg1;
29257   {
29258     try {
29259       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29260     } catch (std::out_of_range& e) {
29261       {
29262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29263       };
29264     } catch (std::exception& e) {
29265       {
29266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29267       };
29268     } catch (Dali::DaliException e) {
29269       {
29270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29271       };
29272     } catch (...) {
29273       {
29274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29275       };
29276     }
29277   }
29278
29279   jresult = result;
29280   return jresult;
29281 }
29282
29283
29284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29285   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29286   unsigned int arg2 ;
29287
29288   arg1 = (Dali::RenderTask *)jarg1;
29289   arg2 = (unsigned int)jarg2;
29290   {
29291     try {
29292       (arg1)->SetRefreshRate(arg2);
29293     } catch (std::out_of_range& e) {
29294       {
29295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29296       };
29297     } catch (std::exception& e) {
29298       {
29299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29300       };
29301     } catch (Dali::DaliException e) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29304       };
29305     } catch (...) {
29306       {
29307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29308       };
29309     }
29310   }
29311
29312 }
29313
29314
29315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29316   unsigned int jresult ;
29317   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29318   unsigned int result;
29319
29320   arg1 = (Dali::RenderTask *)jarg1;
29321   {
29322     try {
29323       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29324     } catch (std::out_of_range& e) {
29325       {
29326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (std::exception& e) {
29329       {
29330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29331       };
29332     } catch (Dali::DaliException e) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29335       };
29336     } catch (...) {
29337       {
29338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29339       };
29340     }
29341   }
29342
29343   jresult = result;
29344   return jresult;
29345 }
29346
29347
29348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29349   unsigned int jresult ;
29350   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29351   Dali::Vector3 *arg2 = 0 ;
29352   float *arg3 = 0 ;
29353   float *arg4 = 0 ;
29354   bool result;
29355
29356   arg1 = (Dali::RenderTask *)jarg1;
29357   arg2 = (Dali::Vector3 *)jarg2;
29358   if (!arg2) {
29359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29360     return 0;
29361   }
29362   arg3 = (float *)jarg3;
29363   arg4 = (float *)jarg4;
29364   {
29365     try {
29366       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29367     } catch (std::out_of_range& e) {
29368       {
29369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29370       };
29371     } catch (std::exception& e) {
29372       {
29373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29374       };
29375     } catch (Dali::DaliException e) {
29376       {
29377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29378       };
29379     } catch (...) {
29380       {
29381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29382       };
29383     }
29384   }
29385
29386   jresult = result;
29387   return jresult;
29388 }
29389
29390
29391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29392   unsigned int jresult ;
29393   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29394   Dali::Actor arg2 ;
29395   float arg3 ;
29396   float arg4 ;
29397   float *arg5 = 0 ;
29398   float *arg6 = 0 ;
29399   Dali::Actor *argp2 ;
29400   bool result;
29401
29402   arg1 = (Dali::RenderTask *)jarg1;
29403   argp2 = (Dali::Actor *)jarg2;
29404   if (!argp2) {
29405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29406     return 0;
29407   }
29408   arg2 = *argp2;
29409   arg3 = (float)jarg3;
29410   arg4 = (float)jarg4;
29411   arg5 = (float *)jarg5;
29412   arg6 = (float *)jarg6;
29413   {
29414     try {
29415       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29416     } catch (std::out_of_range& e) {
29417       {
29418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29419       };
29420     } catch (std::exception& e) {
29421       {
29422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29423       };
29424     } catch (Dali::DaliException e) {
29425       {
29426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29427       };
29428     } catch (...) {
29429       {
29430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29431       };
29432     }
29433   }
29434
29435   jresult = result;
29436   return jresult;
29437 }
29438
29439
29440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29441   void * jresult ;
29442   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29443   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29444
29445   arg1 = (Dali::RenderTask *)jarg1;
29446   {
29447     try {
29448       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29449     } catch (std::out_of_range& e) {
29450       {
29451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29452       };
29453     } catch (std::exception& e) {
29454       {
29455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29456       };
29457     } catch (Dali::DaliException e) {
29458       {
29459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29460       };
29461     } catch (...) {
29462       {
29463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29464       };
29465     }
29466   }
29467
29468   jresult = (void *)result;
29469   return jresult;
29470 }
29471
29472
29473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29474   void * jresult ;
29475   int arg1 ;
29476   Dali::TouchPoint::State arg2 ;
29477   float arg3 ;
29478   float arg4 ;
29479   Dali::TouchPoint *result = 0 ;
29480
29481   arg1 = (int)jarg1;
29482   arg2 = (Dali::TouchPoint::State)jarg2;
29483   arg3 = (float)jarg3;
29484   arg4 = (float)jarg4;
29485   {
29486     try {
29487       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29488     } catch (std::out_of_range& e) {
29489       {
29490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29491       };
29492     } catch (std::exception& e) {
29493       {
29494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29495       };
29496     } catch (Dali::DaliException e) {
29497       {
29498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29499       };
29500     } catch (...) {
29501       {
29502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29503       };
29504     }
29505   }
29506
29507   jresult = (void *)result;
29508   return jresult;
29509 }
29510
29511
29512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29513   void * jresult ;
29514   int arg1 ;
29515   Dali::TouchPoint::State arg2 ;
29516   float arg3 ;
29517   float arg4 ;
29518   float arg5 ;
29519   float arg6 ;
29520   Dali::TouchPoint *result = 0 ;
29521
29522   arg1 = (int)jarg1;
29523   arg2 = (Dali::TouchPoint::State)jarg2;
29524   arg3 = (float)jarg3;
29525   arg4 = (float)jarg4;
29526   arg5 = (float)jarg5;
29527   arg6 = (float)jarg6;
29528   {
29529     try {
29530       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29531     } catch (std::out_of_range& e) {
29532       {
29533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29534       };
29535     } catch (std::exception& e) {
29536       {
29537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (Dali::DaliException e) {
29540       {
29541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29542       };
29543     } catch (...) {
29544       {
29545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29546       };
29547     }
29548   }
29549
29550   jresult = (void *)result;
29551   return jresult;
29552 }
29553
29554
29555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29556   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29557
29558   arg1 = (Dali::TouchPoint *)jarg1;
29559   {
29560     try {
29561       delete arg1;
29562     } catch (std::out_of_range& e) {
29563       {
29564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29565       };
29566     } catch (std::exception& e) {
29567       {
29568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29569       };
29570     } catch (Dali::DaliException e) {
29571       {
29572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29573       };
29574     } catch (...) {
29575       {
29576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29577       };
29578     }
29579   }
29580
29581 }
29582
29583
29584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29585   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29586   int arg2 ;
29587
29588   arg1 = (Dali::TouchPoint *)jarg1;
29589   arg2 = (int)jarg2;
29590   if (arg1) (arg1)->deviceId = arg2;
29591 }
29592
29593
29594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29595   int jresult ;
29596   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29597   int result;
29598
29599   arg1 = (Dali::TouchPoint *)jarg1;
29600   result = (int) ((arg1)->deviceId);
29601   jresult = result;
29602   return jresult;
29603 }
29604
29605
29606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29607   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29608   Dali::TouchPoint::State arg2 ;
29609
29610   arg1 = (Dali::TouchPoint *)jarg1;
29611   arg2 = (Dali::TouchPoint::State)jarg2;
29612   if (arg1) (arg1)->state = arg2;
29613 }
29614
29615
29616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29617   int jresult ;
29618   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29619   Dali::TouchPoint::State result;
29620
29621   arg1 = (Dali::TouchPoint *)jarg1;
29622   result = (Dali::TouchPoint::State) ((arg1)->state);
29623   jresult = (int)result;
29624   return jresult;
29625 }
29626
29627
29628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29629   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29630   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29631
29632   arg1 = (Dali::TouchPoint *)jarg1;
29633   arg2 = (Dali::Actor *)jarg2;
29634   if (arg1) (arg1)->hitActor = *arg2;
29635 }
29636
29637
29638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29639   void * jresult ;
29640   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29641   Dali::Actor *result = 0 ;
29642
29643   arg1 = (Dali::TouchPoint *)jarg1;
29644   result = (Dali::Actor *)& ((arg1)->hitActor);
29645   jresult = (void *)result;
29646   return jresult;
29647 }
29648
29649
29650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29651   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29652   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29653
29654   arg1 = (Dali::TouchPoint *)jarg1;
29655   arg2 = (Dali::Vector2 *)jarg2;
29656   if (arg1) (arg1)->local = *arg2;
29657 }
29658
29659
29660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29661   void * jresult ;
29662   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29663   Dali::Vector2 *result = 0 ;
29664
29665   arg1 = (Dali::TouchPoint *)jarg1;
29666   result = (Dali::Vector2 *)& ((arg1)->local);
29667   jresult = (void *)result;
29668   return jresult;
29669 }
29670
29671
29672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29673   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29674   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29675
29676   arg1 = (Dali::TouchPoint *)jarg1;
29677   arg2 = (Dali::Vector2 *)jarg2;
29678   if (arg1) (arg1)->screen = *arg2;
29679 }
29680
29681
29682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29683   void * jresult ;
29684   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29685   Dali::Vector2 *result = 0 ;
29686
29687   arg1 = (Dali::TouchPoint *)jarg1;
29688   result = (Dali::Vector2 *)& ((arg1)->screen);
29689   jresult = (void *)result;
29690   return jresult;
29691 }
29692
29693
29694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29695   void * jresult ;
29696   Dali::TouchData *result = 0 ;
29697
29698   {
29699     try {
29700       result = (Dali::TouchData *)new Dali::TouchData();
29701     } catch (std::out_of_range& e) {
29702       {
29703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29704       };
29705     } catch (std::exception& e) {
29706       {
29707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29708       };
29709     } catch (Dali::DaliException e) {
29710       {
29711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29712       };
29713     } catch (...) {
29714       {
29715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29716       };
29717     }
29718   }
29719
29720   jresult = (void *)result;
29721   return jresult;
29722 }
29723
29724
29725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29726   void * jresult ;
29727   Dali::TouchData *arg1 = 0 ;
29728   Dali::TouchData *result = 0 ;
29729
29730   arg1 = (Dali::TouchData *)jarg1;
29731   if (!arg1) {
29732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29733     return 0;
29734   }
29735   {
29736     try {
29737       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29738     } catch (std::out_of_range& e) {
29739       {
29740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (std::exception& e) {
29743       {
29744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29745       };
29746     } catch (Dali::DaliException e) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29749       };
29750     } catch (...) {
29751       {
29752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29753       };
29754     }
29755   }
29756
29757   jresult = (void *)result;
29758   return jresult;
29759 }
29760
29761
29762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29763   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29764
29765   arg1 = (Dali::TouchData *)jarg1;
29766   {
29767     try {
29768       delete arg1;
29769     } catch (std::out_of_range& e) {
29770       {
29771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29772       };
29773     } catch (std::exception& e) {
29774       {
29775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29776       };
29777     } catch (Dali::DaliException e) {
29778       {
29779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29780       };
29781     } catch (...) {
29782       {
29783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29784       };
29785     }
29786   }
29787
29788 }
29789
29790
29791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29792   void * jresult ;
29793   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29794   Dali::TouchData *arg2 = 0 ;
29795   Dali::TouchData *result = 0 ;
29796
29797   arg1 = (Dali::TouchData *)jarg1;
29798   arg2 = (Dali::TouchData *)jarg2;
29799   if (!arg2) {
29800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29801     return 0;
29802   }
29803   {
29804     try {
29805       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29806     } catch (std::out_of_range& e) {
29807       {
29808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29809       };
29810     } catch (std::exception& e) {
29811       {
29812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29813       };
29814     } catch (Dali::DaliException e) {
29815       {
29816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29817       };
29818     } catch (...) {
29819       {
29820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29821       };
29822     }
29823   }
29824
29825   jresult = (void *)result;
29826   return jresult;
29827 }
29828
29829
29830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29831   unsigned long jresult ;
29832   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29833   unsigned long result;
29834
29835   arg1 = (Dali::TouchData *)jarg1;
29836   {
29837     try {
29838       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29839     } catch (std::out_of_range& e) {
29840       {
29841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29842       };
29843     } catch (std::exception& e) {
29844       {
29845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29846       };
29847     } catch (Dali::DaliException e) {
29848       {
29849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29850       };
29851     } catch (...) {
29852       {
29853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29854       };
29855     }
29856   }
29857
29858   jresult = (unsigned long)result;
29859   return jresult;
29860 }
29861
29862
29863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29864   unsigned long jresult ;
29865   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29866   std::size_t result;
29867
29868   arg1 = (Dali::TouchData *)jarg1;
29869   {
29870     try {
29871       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29872     } catch (std::out_of_range& e) {
29873       {
29874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29875       };
29876     } catch (std::exception& e) {
29877       {
29878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29879       };
29880     } catch (Dali::DaliException e) {
29881       {
29882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29883       };
29884     } catch (...) {
29885       {
29886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29887       };
29888     }
29889   }
29890
29891   jresult = (unsigned long)result;
29892   return jresult;
29893 }
29894
29895
29896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29897   int jresult ;
29898   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29899   std::size_t arg2 ;
29900   int32_t result;
29901
29902   arg1 = (Dali::TouchData *)jarg1;
29903   arg2 = (std::size_t)jarg2;
29904   {
29905     try {
29906       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29907     } catch (std::out_of_range& e) {
29908       {
29909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29910       };
29911     } catch (std::exception& e) {
29912       {
29913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29914       };
29915     } catch (Dali::DaliException e) {
29916       {
29917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29918       };
29919     } catch (...) {
29920       {
29921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29922       };
29923     }
29924   }
29925
29926   jresult = result;
29927   return jresult;
29928 }
29929
29930
29931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29932   int jresult ;
29933   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29934   std::size_t arg2 ;
29935   Dali::PointState::Type result;
29936
29937   arg1 = (Dali::TouchData *)jarg1;
29938   arg2 = (std::size_t)jarg2;
29939   {
29940     try {
29941       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29942     } catch (std::out_of_range& e) {
29943       {
29944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29945       };
29946     } catch (std::exception& e) {
29947       {
29948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29949       };
29950     } catch (Dali::DaliException e) {
29951       {
29952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29953       };
29954     } catch (...) {
29955       {
29956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29957       };
29958     }
29959   }
29960
29961   jresult = (int)result;
29962   return jresult;
29963 }
29964
29965
29966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29967   void * jresult ;
29968   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29969   std::size_t arg2 ;
29970   Dali::Actor result;
29971
29972   arg1 = (Dali::TouchData *)jarg1;
29973   arg2 = (std::size_t)jarg2;
29974   {
29975     try {
29976       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29977     } catch (std::out_of_range& e) {
29978       {
29979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29980       };
29981     } catch (std::exception& e) {
29982       {
29983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29984       };
29985     } catch (Dali::DaliException e) {
29986       {
29987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29988       };
29989     } catch (...) {
29990       {
29991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29992       };
29993     }
29994   }
29995
29996   jresult = new Dali::Actor((const Dali::Actor &)result);
29997   return jresult;
29998 }
29999
30000
30001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30002   void * jresult ;
30003   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30004   std::size_t arg2 ;
30005   Dali::Vector2 *result = 0 ;
30006
30007   arg1 = (Dali::TouchData *)jarg1;
30008   arg2 = (std::size_t)jarg2;
30009   {
30010     try {
30011       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30012     } catch (std::out_of_range& e) {
30013       {
30014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30015       };
30016     } catch (std::exception& e) {
30017       {
30018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30019       };
30020     } catch (Dali::DaliException e) {
30021       {
30022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30023       };
30024     } catch (...) {
30025       {
30026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30027       };
30028     }
30029   }
30030
30031   jresult = (void *)result;
30032   return jresult;
30033 }
30034
30035
30036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30037   void * jresult ;
30038   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30039   std::size_t arg2 ;
30040   Dali::Vector2 *result = 0 ;
30041
30042   arg1 = (Dali::TouchData *)jarg1;
30043   arg2 = (std::size_t)jarg2;
30044   {
30045     try {
30046       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30047     } catch (std::out_of_range& e) {
30048       {
30049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30050       };
30051     } catch (std::exception& e) {
30052       {
30053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30054       };
30055     } catch (Dali::DaliException e) {
30056       {
30057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30058       };
30059     } catch (...) {
30060       {
30061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30062       };
30063     }
30064   }
30065
30066   jresult = (void *)result;
30067   return jresult;
30068 }
30069
30070
30071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30072   float jresult ;
30073   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30074   std::size_t arg2 ;
30075   float result;
30076
30077   arg1 = (Dali::TouchData *)jarg1;
30078   arg2 = (std::size_t)jarg2;
30079   {
30080     try {
30081       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30082     } catch (std::out_of_range& e) {
30083       {
30084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30085       };
30086     } catch (std::exception& e) {
30087       {
30088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30089       };
30090     } catch (Dali::DaliException e) {
30091       {
30092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30093       };
30094     } catch (...) {
30095       {
30096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30097       };
30098     }
30099   }
30100
30101   jresult = result;
30102   return jresult;
30103 }
30104
30105
30106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30107   void * jresult ;
30108   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30109   std::size_t arg2 ;
30110   Dali::Vector2 *result = 0 ;
30111
30112   arg1 = (Dali::TouchData *)jarg1;
30113   arg2 = (std::size_t)jarg2;
30114   {
30115     try {
30116       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30117     } catch (std::out_of_range& e) {
30118       {
30119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30120       };
30121     } catch (std::exception& e) {
30122       {
30123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30124       };
30125     } catch (Dali::DaliException e) {
30126       {
30127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30128       };
30129     } catch (...) {
30130       {
30131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30132       };
30133     }
30134   }
30135
30136   jresult = (void *)result;
30137   return jresult;
30138 }
30139
30140
30141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30142   float jresult ;
30143   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30144   std::size_t arg2 ;
30145   float result;
30146
30147   arg1 = (Dali::TouchData *)jarg1;
30148   arg2 = (std::size_t)jarg2;
30149   {
30150     try {
30151       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30152     } catch (std::out_of_range& e) {
30153       {
30154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30155       };
30156     } catch (std::exception& e) {
30157       {
30158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30159       };
30160     } catch (Dali::DaliException e) {
30161       {
30162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30163       };
30164     } catch (...) {
30165       {
30166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30167       };
30168     }
30169   }
30170
30171   jresult = result;
30172   return jresult;
30173 }
30174
30175
30176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30177   void * jresult ;
30178   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30179   std::size_t arg2 ;
30180   Dali::Degree result;
30181
30182   arg1 = (Dali::TouchData *)jarg1;
30183   arg2 = (std::size_t)jarg2;
30184   {
30185     try {
30186       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30187     } catch (std::out_of_range& e) {
30188       {
30189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30190       };
30191     } catch (std::exception& e) {
30192       {
30193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30194       };
30195     } catch (Dali::DaliException e) {
30196       {
30197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30198       };
30199     } catch (...) {
30200       {
30201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30202       };
30203     }
30204   }
30205
30206   jresult = new Dali::Degree((const Dali::Degree &)result);
30207   return jresult;
30208 }
30209
30210
30211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30212   int jresult ;
30213   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30214   std::size_t arg2 ;
30215   Dali::MouseButton::Type result;
30216
30217   arg1 = (Dali::TouchData *)jarg1;
30218   arg2 = (std::size_t)jarg2;
30219   {
30220     try {
30221       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30222     } catch (std::out_of_range& e) {
30223       {
30224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30225       };
30226     } catch (std::exception& e) {
30227       {
30228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30229       };
30230     } catch (Dali::DaliException e) {
30231       {
30232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30233       };
30234     } catch (...) {
30235       {
30236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30237       };
30238     }
30239   }
30240
30241   jresult = static_cast< int >(result);
30242   return jresult;
30243 }
30244
30245
30246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30247   void * jresult ;
30248   Dali::GestureDetector *result = 0 ;
30249
30250   {
30251     try {
30252       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30253     } catch (std::out_of_range& e) {
30254       {
30255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30256       };
30257     } catch (std::exception& e) {
30258       {
30259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30260       };
30261     } catch (Dali::DaliException e) {
30262       {
30263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30264       };
30265     } catch (...) {
30266       {
30267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30268       };
30269     }
30270   }
30271
30272   jresult = (void *)result;
30273   return jresult;
30274 }
30275
30276
30277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30278   void * jresult ;
30279   Dali::BaseHandle arg1 ;
30280   Dali::BaseHandle *argp1 ;
30281   Dali::GestureDetector result;
30282
30283   argp1 = (Dali::BaseHandle *)jarg1;
30284   if (!argp1) {
30285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30286     return 0;
30287   }
30288   arg1 = *argp1;
30289   {
30290     try {
30291       result = Dali::GestureDetector::DownCast(arg1);
30292     } catch (std::out_of_range& e) {
30293       {
30294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30295       };
30296     } catch (std::exception& e) {
30297       {
30298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30299       };
30300     } catch (Dali::DaliException e) {
30301       {
30302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30303       };
30304     } catch (...) {
30305       {
30306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30307       };
30308     }
30309   }
30310
30311   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30312   return jresult;
30313 }
30314
30315
30316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30317   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30318
30319   arg1 = (Dali::GestureDetector *)jarg1;
30320   {
30321     try {
30322       delete arg1;
30323     } catch (std::out_of_range& e) {
30324       {
30325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (std::exception& e) {
30328       {
30329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30330       };
30331     } catch (Dali::DaliException e) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30334       };
30335     } catch (...) {
30336       {
30337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30338       };
30339     }
30340   }
30341
30342 }
30343
30344
30345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30346   void * jresult ;
30347   Dali::GestureDetector *arg1 = 0 ;
30348   Dali::GestureDetector *result = 0 ;
30349
30350   arg1 = (Dali::GestureDetector *)jarg1;
30351   if (!arg1) {
30352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30353     return 0;
30354   }
30355   {
30356     try {
30357       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30358     } catch (std::out_of_range& e) {
30359       {
30360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30361       };
30362     } catch (std::exception& e) {
30363       {
30364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30365       };
30366     } catch (Dali::DaliException e) {
30367       {
30368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30369       };
30370     } catch (...) {
30371       {
30372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30373       };
30374     }
30375   }
30376
30377   jresult = (void *)result;
30378   return jresult;
30379 }
30380
30381
30382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30383   void * jresult ;
30384   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30385   Dali::GestureDetector *arg2 = 0 ;
30386   Dali::GestureDetector *result = 0 ;
30387
30388   arg1 = (Dali::GestureDetector *)jarg1;
30389   arg2 = (Dali::GestureDetector *)jarg2;
30390   if (!arg2) {
30391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30392     return 0;
30393   }
30394   {
30395     try {
30396       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30397     } catch (std::out_of_range& e) {
30398       {
30399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30400       };
30401     } catch (std::exception& e) {
30402       {
30403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30404       };
30405     } catch (Dali::DaliException e) {
30406       {
30407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30408       };
30409     } catch (...) {
30410       {
30411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30412       };
30413     }
30414   }
30415
30416   jresult = (void *)result;
30417   return jresult;
30418 }
30419
30420
30421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30422   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30423   Dali::Actor arg2 ;
30424   Dali::Actor *argp2 ;
30425
30426   arg1 = (Dali::GestureDetector *)jarg1;
30427   argp2 = (Dali::Actor *)jarg2;
30428   if (!argp2) {
30429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30430     return ;
30431   }
30432   arg2 = *argp2;
30433   {
30434     try {
30435       (arg1)->Attach(arg2);
30436     } catch (std::out_of_range& e) {
30437       {
30438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30439       };
30440     } catch (std::exception& e) {
30441       {
30442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30443       };
30444     } catch (Dali::DaliException e) {
30445       {
30446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30447       };
30448     } catch (...) {
30449       {
30450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30451       };
30452     }
30453   }
30454
30455 }
30456
30457
30458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30459   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30460   Dali::Actor arg2 ;
30461   Dali::Actor *argp2 ;
30462
30463   arg1 = (Dali::GestureDetector *)jarg1;
30464   argp2 = (Dali::Actor *)jarg2;
30465   if (!argp2) {
30466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30467     return ;
30468   }
30469   arg2 = *argp2;
30470   {
30471     try {
30472       (arg1)->Detach(arg2);
30473     } catch (std::out_of_range& e) {
30474       {
30475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30476       };
30477     } catch (std::exception& e) {
30478       {
30479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30480       };
30481     } catch (Dali::DaliException e) {
30482       {
30483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30484       };
30485     } catch (...) {
30486       {
30487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30488       };
30489     }
30490   }
30491
30492 }
30493
30494
30495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30496   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30497
30498   arg1 = (Dali::GestureDetector *)jarg1;
30499   {
30500     try {
30501       (arg1)->DetachAll();
30502     } catch (std::out_of_range& e) {
30503       {
30504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30505       };
30506     } catch (std::exception& e) {
30507       {
30508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30509       };
30510     } catch (Dali::DaliException e) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30513       };
30514     } catch (...) {
30515       {
30516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30517       };
30518     }
30519   }
30520
30521 }
30522
30523
30524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30525   unsigned long jresult ;
30526   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30527   size_t result;
30528
30529   arg1 = (Dali::GestureDetector *)jarg1;
30530   {
30531     try {
30532       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30533     } catch (std::out_of_range& e) {
30534       {
30535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30536       };
30537     } catch (std::exception& e) {
30538       {
30539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30540       };
30541     } catch (Dali::DaliException e) {
30542       {
30543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30544       };
30545     } catch (...) {
30546       {
30547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30548       };
30549     }
30550   }
30551
30552   jresult = (unsigned long)result;
30553   return jresult;
30554 }
30555
30556
30557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30558   void * jresult ;
30559   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30560   size_t arg2 ;
30561   Dali::Actor result;
30562
30563   arg1 = (Dali::GestureDetector *)jarg1;
30564   arg2 = (size_t)jarg2;
30565   {
30566     try {
30567       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30568     } catch (std::out_of_range& e) {
30569       {
30570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30571       };
30572     } catch (std::exception& e) {
30573       {
30574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30575       };
30576     } catch (Dali::DaliException e) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30579       };
30580     } catch (...) {
30581       {
30582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30583       };
30584     }
30585   }
30586
30587   jresult = new Dali::Actor((const Dali::Actor &)result);
30588   return jresult;
30589 }
30590
30591
30592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30593   void * jresult ;
30594   Dali::Gesture *arg1 = 0 ;
30595   Dali::Gesture *result = 0 ;
30596
30597   arg1 = (Dali::Gesture *)jarg1;
30598   if (!arg1) {
30599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30600     return 0;
30601   }
30602   {
30603     try {
30604       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30605     } catch (std::out_of_range& e) {
30606       {
30607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30608       };
30609     } catch (std::exception& e) {
30610       {
30611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30612       };
30613     } catch (Dali::DaliException e) {
30614       {
30615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30616       };
30617     } catch (...) {
30618       {
30619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30620       };
30621     }
30622   }
30623
30624   jresult = (void *)result;
30625   return jresult;
30626 }
30627
30628
30629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30630   void * jresult ;
30631   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30632   Dali::Gesture *arg2 = 0 ;
30633   Dali::Gesture *result = 0 ;
30634
30635   arg1 = (Dali::Gesture *)jarg1;
30636   arg2 = (Dali::Gesture *)jarg2;
30637   if (!arg2) {
30638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30639     return 0;
30640   }
30641   {
30642     try {
30643       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30644     } catch (std::out_of_range& e) {
30645       {
30646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30647       };
30648     } catch (std::exception& e) {
30649       {
30650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30651       };
30652     } catch (Dali::DaliException e) {
30653       {
30654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30655       };
30656     } catch (...) {
30657       {
30658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30659       };
30660     }
30661   }
30662
30663   jresult = (void *)result;
30664   return jresult;
30665 }
30666
30667
30668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30669   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30670
30671   arg1 = (Dali::Gesture *)jarg1;
30672   {
30673     try {
30674       delete arg1;
30675     } catch (std::out_of_range& e) {
30676       {
30677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30678       };
30679     } catch (std::exception& e) {
30680       {
30681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30682       };
30683     } catch (Dali::DaliException e) {
30684       {
30685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30686       };
30687     } catch (...) {
30688       {
30689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30690       };
30691     }
30692   }
30693
30694 }
30695
30696
30697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30698   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30699   Dali::Gesture::Type arg2 ;
30700
30701   arg1 = (Dali::Gesture *)jarg1;
30702   arg2 = (Dali::Gesture::Type)jarg2;
30703   if (arg1) (arg1)->type = arg2;
30704 }
30705
30706
30707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30708   int jresult ;
30709   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30710   Dali::Gesture::Type result;
30711
30712   arg1 = (Dali::Gesture *)jarg1;
30713   result = (Dali::Gesture::Type) ((arg1)->type);
30714   jresult = (int)result;
30715   return jresult;
30716 }
30717
30718
30719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30720   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30721   Dali::Gesture::State arg2 ;
30722
30723   arg1 = (Dali::Gesture *)jarg1;
30724   arg2 = (Dali::Gesture::State)jarg2;
30725   if (arg1) (arg1)->state = arg2;
30726 }
30727
30728
30729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30730   int jresult ;
30731   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30732   Dali::Gesture::State result;
30733
30734   arg1 = (Dali::Gesture *)jarg1;
30735   result = (Dali::Gesture::State) ((arg1)->state);
30736   jresult = (int)result;
30737   return jresult;
30738 }
30739
30740
30741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30742   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30743   unsigned int arg2 ;
30744
30745   arg1 = (Dali::Gesture *)jarg1;
30746   arg2 = (unsigned int)jarg2;
30747   if (arg1) (arg1)->time = arg2;
30748 }
30749
30750
30751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30752   unsigned int jresult ;
30753   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30754   unsigned int result;
30755
30756   arg1 = (Dali::Gesture *)jarg1;
30757   result = (unsigned int) ((arg1)->time);
30758   jresult = result;
30759   return jresult;
30760 }
30761
30762
30763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30764   void * jresult ;
30765   Dali::HoverEvent *result = 0 ;
30766
30767   {
30768     try {
30769       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30770     } catch (std::out_of_range& e) {
30771       {
30772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30773       };
30774     } catch (std::exception& e) {
30775       {
30776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30777       };
30778     } catch (Dali::DaliException e) {
30779       {
30780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30781       };
30782     } catch (...) {
30783       {
30784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30785       };
30786     }
30787   }
30788
30789   jresult = (void *)result;
30790   return jresult;
30791 }
30792
30793
30794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30795   void * jresult ;
30796   unsigned long arg1 ;
30797   Dali::HoverEvent *result = 0 ;
30798
30799   arg1 = (unsigned long)jarg1;
30800   {
30801     try {
30802       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30803     } catch (std::out_of_range& e) {
30804       {
30805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30806       };
30807     } catch (std::exception& e) {
30808       {
30809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30810       };
30811     } catch (Dali::DaliException e) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30814       };
30815     } catch (...) {
30816       {
30817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30818       };
30819     }
30820   }
30821
30822   jresult = (void *)result;
30823   return jresult;
30824 }
30825
30826
30827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30828   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30829
30830   arg1 = (Dali::HoverEvent *)jarg1;
30831   {
30832     try {
30833       delete arg1;
30834     } catch (std::out_of_range& e) {
30835       {
30836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30837       };
30838     } catch (std::exception& e) {
30839       {
30840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30841       };
30842     } catch (Dali::DaliException e) {
30843       {
30844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30845       };
30846     } catch (...) {
30847       {
30848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30849       };
30850     }
30851   }
30852
30853 }
30854
30855
30856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30857   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30858   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30859
30860   arg1 = (Dali::HoverEvent *)jarg1;
30861   arg2 = (Dali::TouchPointContainer *)jarg2;
30862   if (arg1) (arg1)->points = *arg2;
30863 }
30864
30865
30866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30867   void * jresult ;
30868   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30869   Dali::TouchPointContainer *result = 0 ;
30870
30871   arg1 = (Dali::HoverEvent *)jarg1;
30872   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30873   jresult = (void *)result;
30874   return jresult;
30875 }
30876
30877
30878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30879   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30880   unsigned long arg2 ;
30881
30882   arg1 = (Dali::HoverEvent *)jarg1;
30883   arg2 = (unsigned long)jarg2;
30884   if (arg1) (arg1)->time = arg2;
30885 }
30886
30887
30888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30889   unsigned long jresult ;
30890   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30891   unsigned long result;
30892
30893   arg1 = (Dali::HoverEvent *)jarg1;
30894   result = (unsigned long) ((arg1)->time);
30895   jresult = (unsigned long)result;
30896   return jresult;
30897 }
30898
30899
30900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30901   unsigned int jresult ;
30902   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30903   unsigned int result;
30904
30905   arg1 = (Dali::HoverEvent *)jarg1;
30906   {
30907     try {
30908       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30909     } catch (std::out_of_range& e) {
30910       {
30911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30912       };
30913     } catch (std::exception& e) {
30914       {
30915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (Dali::DaliException e) {
30918       {
30919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30920       };
30921     } catch (...) {
30922       {
30923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30924       };
30925     }
30926   }
30927
30928   jresult = result;
30929   return jresult;
30930 }
30931
30932
30933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30934   void * jresult ;
30935   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30936   unsigned int arg2 ;
30937   Dali::TouchPoint *result = 0 ;
30938
30939   arg1 = (Dali::HoverEvent *)jarg1;
30940   arg2 = (unsigned int)jarg2;
30941   {
30942     try {
30943       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30944     } catch (std::out_of_range& e) {
30945       {
30946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30947       };
30948     } catch (std::exception& e) {
30949       {
30950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30951       };
30952     } catch (Dali::DaliException e) {
30953       {
30954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30955       };
30956     } catch (...) {
30957       {
30958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30959       };
30960     }
30961   }
30962
30963   jresult = (void *)result;
30964   return jresult;
30965 }
30966
30967
30968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30969   void * jresult ;
30970   Dali::KeyEvent *result = 0 ;
30971
30972   {
30973     try {
30974       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30975     } catch (std::out_of_range& e) {
30976       {
30977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30978       };
30979     } catch (std::exception& e) {
30980       {
30981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30982       };
30983     } catch (Dali::DaliException e) {
30984       {
30985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30986       };
30987     } catch (...) {
30988       {
30989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30990       };
30991     }
30992   }
30993
30994   jresult = (void *)result;
30995   return jresult;
30996 }
30997
30998
30999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31000   void * jresult ;
31001   std::string *arg1 = 0 ;
31002   std::string *arg2 = 0 ;
31003   int arg3 ;
31004   int arg4 ;
31005   unsigned long arg5 ;
31006   Dali::KeyEvent::State *arg6 = 0 ;
31007   Dali::KeyEvent::State temp6 ;
31008   Dali::KeyEvent *result = 0 ;
31009
31010   if (!jarg1) {
31011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31012     return 0;
31013   }
31014   std::string arg1_str(jarg1);
31015   arg1 = &arg1_str;
31016   if (!jarg2) {
31017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31018     return 0;
31019   }
31020   std::string arg2_str(jarg2);
31021   arg2 = &arg2_str;
31022   arg3 = (int)jarg3;
31023   arg4 = (int)jarg4;
31024   arg5 = (unsigned long)jarg5;
31025   temp6 = (Dali::KeyEvent::State)jarg6;
31026   arg6 = &temp6;
31027   {
31028     try {
31029       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31030     } catch (std::out_of_range& e) {
31031       {
31032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31033       };
31034     } catch (std::exception& e) {
31035       {
31036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31037       };
31038     } catch (Dali::DaliException e) {
31039       {
31040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31041       };
31042     } catch (...) {
31043       {
31044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31045       };
31046     }
31047   }
31048
31049   jresult = (void *)result;
31050
31051   //argout typemap for const std::string&
31052
31053
31054   //argout typemap for const std::string&
31055
31056   return jresult;
31057 }
31058
31059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31060   void * jresult ;
31061   Dali::KeyEvent *arg1 = 0 ;
31062   Dali::KeyEvent *result = 0 ;
31063
31064   arg1 = (Dali::KeyEvent *)jarg1;
31065   if (!arg1) {
31066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31067     return 0;
31068   }
31069   {
31070     try {
31071       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31072     } catch (std::out_of_range& e) {
31073       {
31074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31075       };
31076     } catch (std::exception& e) {
31077       {
31078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31079       };
31080     } catch (Dali::DaliException e) {
31081       {
31082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31083       };
31084     } catch (...) {
31085       {
31086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31087       };
31088     }
31089   }
31090
31091   jresult = (void *)result;
31092   return jresult;
31093 }
31094
31095
31096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31097   void * jresult ;
31098   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31099   Dali::KeyEvent *arg2 = 0 ;
31100   Dali::KeyEvent *result = 0 ;
31101
31102   arg1 = (Dali::KeyEvent *)jarg1;
31103   arg2 = (Dali::KeyEvent *)jarg2;
31104   if (!arg2) {
31105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31106     return 0;
31107   }
31108   {
31109     try {
31110       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31111     } catch (std::out_of_range& e) {
31112       {
31113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (std::exception& e) {
31116       {
31117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31118       };
31119     } catch (Dali::DaliException e) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31122       };
31123     } catch (...) {
31124       {
31125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31126       };
31127     }
31128   }
31129
31130   jresult = (void *)result;
31131   return jresult;
31132 }
31133
31134
31135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31136   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31137
31138   arg1 = (Dali::KeyEvent *)jarg1;
31139   {
31140     try {
31141       delete arg1;
31142     } catch (std::out_of_range& e) {
31143       {
31144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31145       };
31146     } catch (std::exception& e) {
31147       {
31148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31149       };
31150     } catch (Dali::DaliException e) {
31151       {
31152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31153       };
31154     } catch (...) {
31155       {
31156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31157       };
31158     }
31159   }
31160
31161 }
31162
31163
31164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31165   unsigned int jresult ;
31166   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31167   bool result;
31168
31169   arg1 = (Dali::KeyEvent *)jarg1;
31170   {
31171     try {
31172       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31173     } catch (std::out_of_range& e) {
31174       {
31175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31176       };
31177     } catch (std::exception& e) {
31178       {
31179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31180       };
31181     } catch (Dali::DaliException e) {
31182       {
31183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31184       };
31185     } catch (...) {
31186       {
31187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31188       };
31189     }
31190   }
31191
31192   jresult = result;
31193   return jresult;
31194 }
31195
31196
31197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31198   unsigned int jresult ;
31199   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31200   bool result;
31201
31202   arg1 = (Dali::KeyEvent *)jarg1;
31203   {
31204     try {
31205       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31206     } catch (std::out_of_range& e) {
31207       {
31208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31209       };
31210     } catch (std::exception& e) {
31211       {
31212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31213       };
31214     } catch (Dali::DaliException e) {
31215       {
31216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31217       };
31218     } catch (...) {
31219       {
31220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31221       };
31222     }
31223   }
31224
31225   jresult = result;
31226   return jresult;
31227 }
31228
31229
31230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31231   unsigned int jresult ;
31232   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31233   bool result;
31234
31235   arg1 = (Dali::KeyEvent *)jarg1;
31236   {
31237     try {
31238       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31239     } catch (std::out_of_range& e) {
31240       {
31241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31242       };
31243     } catch (std::exception& e) {
31244       {
31245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31246       };
31247     } catch (Dali::DaliException e) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31250       };
31251     } catch (...) {
31252       {
31253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31254       };
31255     }
31256   }
31257
31258   jresult = result;
31259   return jresult;
31260 }
31261
31262
31263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31264   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31265   std::string *arg2 = 0 ;
31266
31267   arg1 = (Dali::KeyEvent *)jarg1;
31268   if (!jarg2) {
31269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31270     return ;
31271   }
31272   std::string arg2_str(jarg2);
31273   arg2 = &arg2_str;
31274   if (arg1) (arg1)->keyPressedName = *arg2;
31275
31276   //argout typemap for const std::string&
31277
31278 }
31279
31280
31281 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31282   char * jresult ;
31283
31284   if( jarg1 == NULL )
31285   {
31286     jresult = SWIG_csharp_string_callback( "" );
31287   }
31288   else
31289   {
31290     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31291     std::string *result = 0;
31292
31293     arg1 = ( Dali::KeyEvent * )jarg1;
31294     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31295     jresult = SWIG_csharp_string_callback( result->c_str() );
31296   }
31297
31298   return jresult;
31299 }
31300
31301
31302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31303   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31304   std::string *arg2 = 0 ;
31305
31306   arg1 = (Dali::KeyEvent *)jarg1;
31307   if (!jarg2) {
31308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31309     return ;
31310   }
31311   std::string arg2_str(jarg2);
31312   arg2 = &arg2_str;
31313   if (arg1) (arg1)->keyPressed = *arg2;
31314
31315   //argout typemap for const std::string&
31316
31317 }
31318
31319
31320 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31321   char * jresult ;
31322   if( NULL == jarg1 )
31323   {
31324     jresult = SWIG_csharp_string_callback( "" );
31325   }
31326   else
31327   {
31328     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31329     std::string *result = 0;
31330
31331     arg1 = ( Dali::KeyEvent * )jarg1;
31332     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31333     jresult = SWIG_csharp_string_callback( result->c_str() );
31334   }
31335   return jresult;
31336 }
31337
31338
31339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31340   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31341   int arg2 ;
31342
31343   arg1 = (Dali::KeyEvent *)jarg1;
31344   arg2 = (int)jarg2;
31345   if (arg1) (arg1)->keyCode = arg2;
31346 }
31347
31348
31349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31350   int jresult ;
31351   if( NULL == jarg1 )
31352   {
31353     jresult = -1;
31354   }
31355   else
31356   {
31357     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31358     int result;
31359
31360     arg1 = ( Dali::KeyEvent * )jarg1;
31361     result = (int)( ( arg1 )->keyCode );
31362     jresult = result;
31363   }
31364   return jresult;
31365 }
31366
31367
31368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31369   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31370   int arg2 ;
31371
31372   arg1 = (Dali::KeyEvent *)jarg1;
31373   arg2 = (int)jarg2;
31374   if (arg1) (arg1)->keyModifier = arg2;
31375 }
31376
31377
31378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31379   int jresult ;
31380   if( jarg1 == NULL )
31381   {
31382     jresult = -1;
31383   }
31384   else
31385   {
31386     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31387     int result;
31388
31389     arg1 = ( Dali::KeyEvent * )jarg1;
31390     result = (int)( ( arg1 )->keyModifier );
31391     jresult = result;
31392   }
31393   return jresult;
31394 }
31395
31396
31397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31398   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31399   unsigned long arg2 ;
31400
31401   arg1 = (Dali::KeyEvent *)jarg1;
31402   arg2 = (unsigned long)jarg2;
31403   if (arg1) (arg1)->time = arg2;
31404 }
31405
31406
31407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31408   unsigned long jresult ;
31409   if( jarg1 == NULL )
31410   {
31411     jresult = 0;
31412   }
31413   else
31414   {
31415     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31416     unsigned long result;
31417
31418     arg1 = ( Dali::KeyEvent * )jarg1;
31419     result = (unsigned long)( ( arg1 )->time );
31420     jresult = (unsigned long)result;
31421   }
31422   return jresult;
31423 }
31424
31425
31426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31427   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31428   Dali::KeyEvent::State arg2 ;
31429
31430   arg1 = (Dali::KeyEvent *)jarg1;
31431   arg2 = (Dali::KeyEvent::State)jarg2;
31432   if (arg1) (arg1)->state = arg2;
31433 }
31434
31435
31436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31437   int jresult ;
31438   if( jarg1 == NULL )
31439   {
31440     jresult = -1;
31441   }
31442   else
31443   {
31444     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31445     Dali::KeyEvent::State result;
31446
31447     arg1 = ( Dali::KeyEvent * )jarg1;
31448     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31449     jresult = (int)result;
31450   }
31451   return jresult;
31452 }
31453
31454
31455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31456   void * jresult ;
31457   Dali::LongPressGestureDetector *result = 0 ;
31458
31459   {
31460     try {
31461       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31462     } catch (std::out_of_range& e) {
31463       {
31464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31465       };
31466     } catch (std::exception& e) {
31467       {
31468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31469       };
31470     } catch (Dali::DaliException e) {
31471       {
31472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31473       };
31474     } catch (...) {
31475       {
31476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31477       };
31478     }
31479   }
31480
31481   jresult = (void *)result;
31482   return jresult;
31483 }
31484
31485
31486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31487   void * jresult ;
31488   Dali::LongPressGestureDetector result;
31489
31490   {
31491     try {
31492       result = Dali::LongPressGestureDetector::New();
31493     } catch (std::out_of_range& e) {
31494       {
31495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31496       };
31497     } catch (std::exception& e) {
31498       {
31499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31500       };
31501     } catch (Dali::DaliException e) {
31502       {
31503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31504       };
31505     } catch (...) {
31506       {
31507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31508       };
31509     }
31510   }
31511
31512   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31513   return jresult;
31514 }
31515
31516
31517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31518   void * jresult ;
31519   unsigned int arg1 ;
31520   Dali::LongPressGestureDetector result;
31521
31522   arg1 = (unsigned int)jarg1;
31523   {
31524     try {
31525       result = Dali::LongPressGestureDetector::New(arg1);
31526     } catch (std::out_of_range& e) {
31527       {
31528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31529       };
31530     } catch (std::exception& e) {
31531       {
31532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31533       };
31534     } catch (Dali::DaliException e) {
31535       {
31536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31537       };
31538     } catch (...) {
31539       {
31540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31541       };
31542     }
31543   }
31544
31545   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31546   return jresult;
31547 }
31548
31549
31550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31551   void * jresult ;
31552   unsigned int arg1 ;
31553   unsigned int arg2 ;
31554   Dali::LongPressGestureDetector result;
31555
31556   arg1 = (unsigned int)jarg1;
31557   arg2 = (unsigned int)jarg2;
31558   {
31559     try {
31560       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31561     } catch (std::out_of_range& e) {
31562       {
31563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31564       };
31565     } catch (std::exception& e) {
31566       {
31567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31568       };
31569     } catch (Dali::DaliException e) {
31570       {
31571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31572       };
31573     } catch (...) {
31574       {
31575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31576       };
31577     }
31578   }
31579
31580   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31581   return jresult;
31582 }
31583
31584
31585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31586   void * jresult ;
31587   Dali::BaseHandle arg1 ;
31588   Dali::BaseHandle *argp1 ;
31589   Dali::LongPressGestureDetector result;
31590
31591   argp1 = (Dali::BaseHandle *)jarg1;
31592   if (!argp1) {
31593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31594     return 0;
31595   }
31596   arg1 = *argp1;
31597   {
31598     try {
31599       result = Dali::LongPressGestureDetector::DownCast(arg1);
31600     } catch (std::out_of_range& e) {
31601       {
31602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31603       };
31604     } catch (std::exception& e) {
31605       {
31606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31607       };
31608     } catch (Dali::DaliException e) {
31609       {
31610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31611       };
31612     } catch (...) {
31613       {
31614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31615       };
31616     }
31617   }
31618
31619   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31620   return jresult;
31621 }
31622
31623
31624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31625   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31626
31627   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31628   {
31629     try {
31630       delete arg1;
31631     } catch (std::out_of_range& e) {
31632       {
31633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31634       };
31635     } catch (std::exception& e) {
31636       {
31637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31638       };
31639     } catch (Dali::DaliException e) {
31640       {
31641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31642       };
31643     } catch (...) {
31644       {
31645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31646       };
31647     }
31648   }
31649
31650 }
31651
31652
31653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31654   void * jresult ;
31655   Dali::LongPressGestureDetector *arg1 = 0 ;
31656   Dali::LongPressGestureDetector *result = 0 ;
31657
31658   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31659   if (!arg1) {
31660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31661     return 0;
31662   }
31663   {
31664     try {
31665       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31666     } catch (std::out_of_range& e) {
31667       {
31668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31669       };
31670     } catch (std::exception& e) {
31671       {
31672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31673       };
31674     } catch (Dali::DaliException e) {
31675       {
31676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31677       };
31678     } catch (...) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31681       };
31682     }
31683   }
31684
31685   jresult = (void *)result;
31686   return jresult;
31687 }
31688
31689
31690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31691   void * jresult ;
31692   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31693   Dali::LongPressGestureDetector *arg2 = 0 ;
31694   Dali::LongPressGestureDetector *result = 0 ;
31695
31696   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31697   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31698   if (!arg2) {
31699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31700     return 0;
31701   }
31702   {
31703     try {
31704       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31705     } catch (std::out_of_range& e) {
31706       {
31707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31708       };
31709     } catch (std::exception& e) {
31710       {
31711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31712       };
31713     } catch (Dali::DaliException e) {
31714       {
31715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31716       };
31717     } catch (...) {
31718       {
31719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31720       };
31721     }
31722   }
31723
31724   jresult = (void *)result;
31725   return jresult;
31726 }
31727
31728
31729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31730   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31731   unsigned int arg2 ;
31732
31733   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31734   arg2 = (unsigned int)jarg2;
31735   {
31736     try {
31737       (arg1)->SetTouchesRequired(arg2);
31738     } catch (std::out_of_range& e) {
31739       {
31740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31741       };
31742     } catch (std::exception& e) {
31743       {
31744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31745       };
31746     } catch (Dali::DaliException e) {
31747       {
31748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31749       };
31750     } catch (...) {
31751       {
31752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31753       };
31754     }
31755   }
31756
31757 }
31758
31759
31760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31761   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31762   unsigned int arg2 ;
31763   unsigned int arg3 ;
31764
31765   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31766   arg2 = (unsigned int)jarg2;
31767   arg3 = (unsigned int)jarg3;
31768   {
31769     try {
31770       (arg1)->SetTouchesRequired(arg2,arg3);
31771     } catch (std::out_of_range& e) {
31772       {
31773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31774       };
31775     } catch (std::exception& e) {
31776       {
31777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31778       };
31779     } catch (Dali::DaliException e) {
31780       {
31781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31782       };
31783     } catch (...) {
31784       {
31785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31786       };
31787     }
31788   }
31789
31790 }
31791
31792
31793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31794   unsigned int jresult ;
31795   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31796   unsigned int result;
31797
31798   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31799   {
31800     try {
31801       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31802     } catch (std::out_of_range& e) {
31803       {
31804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31805       };
31806     } catch (std::exception& e) {
31807       {
31808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31809       };
31810     } catch (Dali::DaliException e) {
31811       {
31812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31813       };
31814     } catch (...) {
31815       {
31816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31817       };
31818     }
31819   }
31820
31821   jresult = result;
31822   return jresult;
31823 }
31824
31825
31826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31827   unsigned int jresult ;
31828   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31829   unsigned int result;
31830
31831   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31832   {
31833     try {
31834       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31835     } catch (std::out_of_range& e) {
31836       {
31837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31838       };
31839     } catch (std::exception& e) {
31840       {
31841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31842       };
31843     } catch (Dali::DaliException e) {
31844       {
31845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31846       };
31847     } catch (...) {
31848       {
31849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31850       };
31851     }
31852   }
31853
31854   jresult = result;
31855   return jresult;
31856 }
31857
31858
31859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31860   void * jresult ;
31861   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31862   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31863
31864   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31865   {
31866     try {
31867       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31868     } catch (std::out_of_range& e) {
31869       {
31870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (std::exception& e) {
31873       {
31874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (Dali::DaliException e) {
31877       {
31878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886
31887   jresult = (void *)result;
31888   return jresult;
31889 }
31890
31891
31892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31893   void * jresult ;
31894   Dali::Gesture::State arg1 ;
31895   Dali::LongPressGesture *result = 0 ;
31896
31897   arg1 = (Dali::Gesture::State)jarg1;
31898   {
31899     try {
31900       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31901     } catch (std::out_of_range& e) {
31902       {
31903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31904       };
31905     } catch (std::exception& e) {
31906       {
31907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31908       };
31909     } catch (Dali::DaliException e) {
31910       {
31911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31912       };
31913     } catch (...) {
31914       {
31915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31916       };
31917     }
31918   }
31919
31920   jresult = (void *)result;
31921   return jresult;
31922 }
31923
31924
31925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31926   void * jresult ;
31927   Dali::LongPressGesture *arg1 = 0 ;
31928   Dali::LongPressGesture *result = 0 ;
31929
31930   arg1 = (Dali::LongPressGesture *)jarg1;
31931   if (!arg1) {
31932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31933     return 0;
31934   }
31935   {
31936     try {
31937       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31938     } catch (std::out_of_range& e) {
31939       {
31940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31941       };
31942     } catch (std::exception& e) {
31943       {
31944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31945       };
31946     } catch (Dali::DaliException e) {
31947       {
31948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31949       };
31950     } catch (...) {
31951       {
31952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31953       };
31954     }
31955   }
31956
31957   jresult = (void *)result;
31958   return jresult;
31959 }
31960
31961
31962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31963   void * jresult ;
31964   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31965   Dali::LongPressGesture *arg2 = 0 ;
31966   Dali::LongPressGesture *result = 0 ;
31967
31968   arg1 = (Dali::LongPressGesture *)jarg1;
31969   arg2 = (Dali::LongPressGesture *)jarg2;
31970   if (!arg2) {
31971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31972     return 0;
31973   }
31974   {
31975     try {
31976       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31977     } catch (std::out_of_range& e) {
31978       {
31979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31980       };
31981     } catch (std::exception& e) {
31982       {
31983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31984       };
31985     } catch (Dali::DaliException e) {
31986       {
31987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31988       };
31989     } catch (...) {
31990       {
31991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31992       };
31993     }
31994   }
31995
31996   jresult = (void *)result;
31997   return jresult;
31998 }
31999
32000
32001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32002   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32003
32004   arg1 = (Dali::LongPressGesture *)jarg1;
32005   {
32006     try {
32007       delete arg1;
32008     } catch (std::out_of_range& e) {
32009       {
32010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32011       };
32012     } catch (std::exception& e) {
32013       {
32014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32015       };
32016     } catch (Dali::DaliException e) {
32017       {
32018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32019       };
32020     } catch (...) {
32021       {
32022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32023       };
32024     }
32025   }
32026
32027 }
32028
32029
32030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32031   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32032   unsigned int arg2 ;
32033
32034   arg1 = (Dali::LongPressGesture *)jarg1;
32035   arg2 = (unsigned int)jarg2;
32036   if (arg1) (arg1)->numberOfTouches = arg2;
32037 }
32038
32039
32040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32041   unsigned int jresult ;
32042   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32043   unsigned int result;
32044
32045   arg1 = (Dali::LongPressGesture *)jarg1;
32046   result = (unsigned int) ((arg1)->numberOfTouches);
32047   jresult = result;
32048   return jresult;
32049 }
32050
32051
32052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32053   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32054   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32055
32056   arg1 = (Dali::LongPressGesture *)jarg1;
32057   arg2 = (Dali::Vector2 *)jarg2;
32058   if (arg1) (arg1)->screenPoint = *arg2;
32059 }
32060
32061
32062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32063   void * jresult ;
32064   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32065   Dali::Vector2 *result = 0 ;
32066
32067   arg1 = (Dali::LongPressGesture *)jarg1;
32068   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32069   jresult = (void *)result;
32070   return jresult;
32071 }
32072
32073
32074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32075   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32076   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32077
32078   arg1 = (Dali::LongPressGesture *)jarg1;
32079   arg2 = (Dali::Vector2 *)jarg2;
32080   if (arg1) (arg1)->localPoint = *arg2;
32081 }
32082
32083
32084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32085   void * jresult ;
32086   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32087   Dali::Vector2 *result = 0 ;
32088
32089   arg1 = (Dali::LongPressGesture *)jarg1;
32090   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32091   jresult = (void *)result;
32092   return jresult;
32093 }
32094
32095
32096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32097   void * jresult ;
32098   Dali::WheelEvent *result = 0 ;
32099
32100   {
32101     try {
32102       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32103     } catch (std::out_of_range& e) {
32104       {
32105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32106       };
32107     } catch (std::exception& e) {
32108       {
32109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32110       };
32111     } catch (Dali::DaliException e) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32114       };
32115     } catch (...) {
32116       {
32117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32118       };
32119     }
32120   }
32121
32122   jresult = (void *)result;
32123   return jresult;
32124 }
32125
32126
32127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32128   void * jresult ;
32129   Dali::WheelEvent::Type arg1 ;
32130   int arg2 ;
32131   unsigned int arg3 ;
32132   Dali::Vector2 arg4 ;
32133   int arg5 ;
32134   unsigned int arg6 ;
32135   Dali::Vector2 *argp4 ;
32136   Dali::WheelEvent *result = 0 ;
32137
32138   arg1 = (Dali::WheelEvent::Type)jarg1;
32139   arg2 = (int)jarg2;
32140   arg3 = (unsigned int)jarg3;
32141   argp4 = (Dali::Vector2 *)jarg4;
32142   if (!argp4) {
32143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32144     return 0;
32145   }
32146   arg4 = *argp4;
32147   arg5 = (int)jarg5;
32148   arg6 = (unsigned int)jarg6;
32149   {
32150     try {
32151       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32152     } catch (std::out_of_range& e) {
32153       {
32154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32155       };
32156     } catch (std::exception& e) {
32157       {
32158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32159       };
32160     } catch (Dali::DaliException e) {
32161       {
32162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32163       };
32164     } catch (...) {
32165       {
32166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32167       };
32168     }
32169   }
32170
32171   jresult = (void *)result;
32172   return jresult;
32173 }
32174
32175
32176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32177   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32178
32179   arg1 = (Dali::WheelEvent *)jarg1;
32180   {
32181     try {
32182       delete arg1;
32183     } catch (std::out_of_range& e) {
32184       {
32185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32186       };
32187     } catch (std::exception& e) {
32188       {
32189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32190       };
32191     } catch (Dali::DaliException e) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32194       };
32195     } catch (...) {
32196       {
32197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32198       };
32199     }
32200   }
32201
32202 }
32203
32204
32205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32206   unsigned int jresult ;
32207   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32208   bool result;
32209
32210   arg1 = (Dali::WheelEvent *)jarg1;
32211   {
32212     try {
32213       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32214     } catch (std::out_of_range& e) {
32215       {
32216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32217       };
32218     } catch (std::exception& e) {
32219       {
32220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32221       };
32222     } catch (Dali::DaliException e) {
32223       {
32224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32225       };
32226     } catch (...) {
32227       {
32228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32229       };
32230     }
32231   }
32232
32233   jresult = result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32239   unsigned int jresult ;
32240   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32241   bool result;
32242
32243   arg1 = (Dali::WheelEvent *)jarg1;
32244   {
32245     try {
32246       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32247     } catch (std::out_of_range& e) {
32248       {
32249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (std::exception& e) {
32252       {
32253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (Dali::DaliException e) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32258       };
32259     } catch (...) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32262       };
32263     }
32264   }
32265
32266   jresult = result;
32267   return jresult;
32268 }
32269
32270
32271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32272   unsigned int jresult ;
32273   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32274   bool result;
32275
32276   arg1 = (Dali::WheelEvent *)jarg1;
32277   {
32278     try {
32279       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32280     } catch (std::out_of_range& e) {
32281       {
32282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32283       };
32284     } catch (std::exception& e) {
32285       {
32286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32287       };
32288     } catch (Dali::DaliException e) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32291       };
32292     } catch (...) {
32293       {
32294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32295       };
32296     }
32297   }
32298
32299   jresult = result;
32300   return jresult;
32301 }
32302
32303
32304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32305   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32306   Dali::WheelEvent::Type arg2 ;
32307
32308   arg1 = (Dali::WheelEvent *)jarg1;
32309   arg2 = (Dali::WheelEvent::Type)jarg2;
32310   if (arg1) (arg1)->type = arg2;
32311 }
32312
32313
32314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32315   int jresult ;
32316   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32317   Dali::WheelEvent::Type result;
32318
32319   arg1 = (Dali::WheelEvent *)jarg1;
32320   result = (Dali::WheelEvent::Type) ((arg1)->type);
32321   jresult = (int)result;
32322   return jresult;
32323 }
32324
32325
32326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32327   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32328   int arg2 ;
32329
32330   arg1 = (Dali::WheelEvent *)jarg1;
32331   arg2 = (int)jarg2;
32332   if (arg1) (arg1)->direction = arg2;
32333 }
32334
32335
32336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32337   int jresult ;
32338   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32339   int result;
32340
32341   arg1 = (Dali::WheelEvent *)jarg1;
32342   result = (int) ((arg1)->direction);
32343   jresult = result;
32344   return jresult;
32345 }
32346
32347
32348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32349   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32350   unsigned int arg2 ;
32351
32352   arg1 = (Dali::WheelEvent *)jarg1;
32353   arg2 = (unsigned int)jarg2;
32354   if (arg1) (arg1)->modifiers = arg2;
32355 }
32356
32357
32358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32359   unsigned int jresult ;
32360   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32361   unsigned int result;
32362
32363   arg1 = (Dali::WheelEvent *)jarg1;
32364   result = (unsigned int) ((arg1)->modifiers);
32365   jresult = result;
32366   return jresult;
32367 }
32368
32369
32370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32371   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32372   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32373
32374   arg1 = (Dali::WheelEvent *)jarg1;
32375   arg2 = (Dali::Vector2 *)jarg2;
32376   if (arg1) (arg1)->point = *arg2;
32377 }
32378
32379
32380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32381   void * jresult ;
32382   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32383   Dali::Vector2 *result = 0 ;
32384
32385   arg1 = (Dali::WheelEvent *)jarg1;
32386   result = (Dali::Vector2 *)& ((arg1)->point);
32387   jresult = (void *)result;
32388   return jresult;
32389 }
32390
32391
32392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32393   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32394   int arg2 ;
32395
32396   arg1 = (Dali::WheelEvent *)jarg1;
32397   arg2 = (int)jarg2;
32398   if (arg1) (arg1)->z = arg2;
32399 }
32400
32401
32402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32403   int jresult ;
32404   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32405   int result;
32406
32407   arg1 = (Dali::WheelEvent *)jarg1;
32408   result = (int) ((arg1)->z);
32409   jresult = result;
32410   return jresult;
32411 }
32412
32413
32414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32415   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32416   unsigned int arg2 ;
32417
32418   arg1 = (Dali::WheelEvent *)jarg1;
32419   arg2 = (unsigned int)jarg2;
32420   if (arg1) (arg1)->timeStamp = arg2;
32421 }
32422
32423
32424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32425   unsigned int jresult ;
32426   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32427   unsigned int result;
32428
32429   arg1 = (Dali::WheelEvent *)jarg1;
32430   result = (unsigned int) ((arg1)->timeStamp);
32431   jresult = result;
32432   return jresult;
32433 }
32434
32435 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32436   char * jresult ;
32437   Dali::KeyEvent *arg1 = 0 ;
32438   std::string result;
32439
32440   arg1 = (Dali::KeyEvent *)jarg1;
32441   if (!arg1) {
32442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32443     return 0;
32444   }
32445   {
32446     try {
32447       result = arg1->GetDeviceName();
32448     } catch (std::out_of_range& e) {
32449       {
32450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32451       };
32452     } catch (std::exception& e) {
32453       {
32454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32455       };
32456     } catch (Dali::DaliException e) {
32457       {
32458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32459       };
32460     } catch (...) {
32461       {
32462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32463       };
32464     }
32465   }
32466
32467   jresult = SWIG_csharp_string_callback((&result)->c_str());
32468   return jresult;
32469 }
32470
32471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32472   int jresult ;
32473   Dali::KeyEvent *arg1 = 0 ;
32474   Dali::Device::Class::Type result;
32475
32476   arg1 = (Dali::KeyEvent *)jarg1;
32477   if (!arg1) {
32478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32479     return 0;
32480   }
32481   {
32482     try {
32483       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32484     } catch (std::out_of_range& e) {
32485       {
32486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32487       };
32488     } catch (std::exception& e) {
32489       {
32490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32491       };
32492     } catch (Dali::DaliException e) {
32493       {
32494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32495       };
32496     } catch (...) {
32497       {
32498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32499       };
32500     }
32501   }
32502
32503   jresult = (int)result;
32504   return jresult;
32505 }
32506
32507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32508   int jresult ;
32509   Dali::KeyEvent *arg1 = 0 ;
32510   Dali::Device::Subclass::Type result;
32511
32512   arg1 = (Dali::KeyEvent *)jarg1;
32513   if (!arg1) {
32514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32515     return 0;
32516   }
32517   {
32518     try {
32519       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32520     } catch (std::out_of_range& e) {
32521       {
32522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32523       };
32524     } catch (std::exception& e) {
32525       {
32526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32527       };
32528     } catch (Dali::DaliException e) {
32529       {
32530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32531       };
32532     } catch (...) {
32533       {
32534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32535       };
32536     }
32537   }
32538
32539   jresult = (int)result;
32540   return jresult;
32541 }
32542
32543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32544   Dali::Actor arg1 ;
32545   Dali::Actor *argp1 ;
32546
32547   argp1 = (Dali::Actor *)jarg1;
32548   if (!argp1) {
32549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32550     return ;
32551   }
32552   arg1 = *argp1;
32553   {
32554     try {
32555       arg1.Raise();
32556     } catch (std::out_of_range& e) {
32557       {
32558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32559       };
32560     } catch (std::exception& e) {
32561       {
32562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32563       };
32564     } catch (Dali::DaliException e) {
32565       {
32566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32567       };
32568     } catch (...) {
32569       {
32570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32571       };
32572     }
32573   }
32574
32575 }
32576
32577
32578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32579   Dali::Actor arg1 ;
32580   Dali::Actor *argp1 ;
32581
32582   argp1 = (Dali::Actor *)jarg1;
32583   if (!argp1) {
32584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32585     return ;
32586   }
32587   arg1 = *argp1;
32588   {
32589     try {
32590       arg1.Lower();
32591     } catch (std::out_of_range& e) {
32592       {
32593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32594       };
32595     } catch (std::exception& e) {
32596       {
32597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32598       };
32599     } catch (Dali::DaliException e) {
32600       {
32601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32602       };
32603     } catch (...) {
32604       {
32605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32606       };
32607     }
32608   }
32609
32610 }
32611
32612
32613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32614   Dali::Actor arg1 ;
32615   Dali::Actor *argp1 ;
32616
32617   argp1 = (Dali::Actor *)jarg1;
32618   if (!argp1) {
32619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32620     return ;
32621   }
32622   arg1 = *argp1;
32623   {
32624     try {
32625       arg1.RaiseToTop();
32626     } catch (std::out_of_range& e) {
32627       {
32628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32629       };
32630     } catch (std::exception& e) {
32631       {
32632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32633       };
32634     } catch (Dali::DaliException e) {
32635       {
32636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32637       };
32638     } catch (...) {
32639       {
32640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32641       };
32642     }
32643   }
32644
32645 }
32646
32647
32648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32649   Dali::Actor arg1 ;
32650   Dali::Actor *argp1 ;
32651
32652   argp1 = (Dali::Actor *)jarg1;
32653   if (!argp1) {
32654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32655     return ;
32656   }
32657   arg1 = *argp1;
32658   {
32659     try {
32660       arg1.LowerToBottom();
32661     } catch (std::out_of_range& e) {
32662       {
32663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32664       };
32665     } catch (std::exception& e) {
32666       {
32667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32668       };
32669     } catch (Dali::DaliException e) {
32670       {
32671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32672       };
32673     } catch (...) {
32674       {
32675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32676       };
32677     }
32678   }
32679
32680 }
32681
32682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32683   Dali::Actor arg1 ;
32684   Dali::Actor arg2 ;
32685   Dali::Actor *argp1 ;
32686   Dali::Actor *argp2 ;
32687
32688   argp1 = (Dali::Actor *)jarg1;
32689   if (!argp1) {
32690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32691     return ;
32692   }
32693   arg1 = *argp1;
32694   argp2 = (Dali::Actor *)jarg2;
32695   if (!argp2) {
32696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32697     return ;
32698   }
32699   arg2 = *argp2;
32700   {
32701     try {
32702       arg1.RaiseAbove(arg2);
32703     } catch (std::out_of_range& e) {
32704       {
32705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32706       };
32707     } catch (std::exception& e) {
32708       {
32709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32710       };
32711     } catch (Dali::DaliException e) {
32712       {
32713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32714       };
32715     } catch (...) {
32716       {
32717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32718       };
32719     }
32720   }
32721
32722 }
32723
32724
32725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32726   Dali::Actor arg1 ;
32727   Dali::Actor arg2 ;
32728   Dali::Actor *argp1 ;
32729   Dali::Actor *argp2 ;
32730
32731   argp1 = (Dali::Actor *)jarg1;
32732   if (!argp1) {
32733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32734     return ;
32735   }
32736   arg1 = *argp1;
32737   argp2 = (Dali::Actor *)jarg2;
32738   if (!argp2) {
32739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32740     return ;
32741   }
32742   arg2 = *argp2;
32743   {
32744     try {
32745       arg1.LowerBelow(arg2);
32746     } catch (std::out_of_range& e) {
32747       {
32748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32749       };
32750     } catch (std::exception& e) {
32751       {
32752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32753       };
32754     } catch (Dali::DaliException e) {
32755       {
32756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32757       };
32758     } catch (...) {
32759       {
32760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32761       };
32762     }
32763   }
32764
32765 }
32766
32767
32768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32769   void * jresult ;
32770   Dali::Actor arg1 ;
32771   Dali::Actor *argp1 ;
32772   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32773
32774   argp1 = (Dali::Actor *)jarg1;
32775   if (!argp1) {
32776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32777     return 0;
32778   }
32779   arg1 = *argp1;
32780   {
32781     try {
32782       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32783     } catch (std::out_of_range& e) {
32784       {
32785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32786       };
32787     } catch (std::exception& e) {
32788       {
32789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32790       };
32791     } catch (Dali::DaliException e) {
32792       {
32793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32794       };
32795     } catch (...) {
32796       {
32797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32798       };
32799     }
32800   }
32801
32802   jresult = (void *)result;
32803   return jresult;
32804 }
32805
32806
32807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32808   void * jresult ;
32809   Dali::Actor *arg1 ;
32810   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32811
32812   arg1 = (Dali::Actor *)jarg1;
32813   {
32814     try {
32815       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32816     } catch (std::out_of_range& e) {
32817       {
32818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32819       };
32820     } catch (std::exception& e) {
32821       {
32822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32823       };
32824     } catch (Dali::DaliException e) {
32825       {
32826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32827       };
32828     } catch (...) {
32829       {
32830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32831       };
32832     }
32833   }
32834
32835   jresult = (void *)result;
32836   return jresult;
32837 }
32838
32839
32840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32841   int jresult ;
32842   int result;
32843
32844   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32845   jresult = (int)result;
32846   return jresult;
32847 }
32848
32849
32850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32851   int jresult ;
32852   int result;
32853
32854   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32855   jresult = (int)result;
32856   return jresult;
32857 }
32858
32859
32860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32861   int jresult ;
32862   int result;
32863
32864   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32865   jresult = (int)result;
32866   return jresult;
32867 }
32868
32869
32870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32871   int jresult ;
32872   int result;
32873
32874   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32875   jresult = (int)result;
32876   return jresult;
32877 }
32878
32879
32880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32881   int jresult ;
32882   int result;
32883
32884   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32885   jresult = (int)result;
32886   return jresult;
32887 }
32888
32889
32890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32891   int jresult ;
32892   int result;
32893
32894   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32895   jresult = (int)result;
32896   return jresult;
32897 }
32898
32899
32900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32901   int jresult ;
32902   int result;
32903
32904   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32905   jresult = (int)result;
32906   return jresult;
32907 }
32908
32909
32910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32911   int jresult ;
32912   int result;
32913
32914   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32915   jresult = (int)result;
32916   return jresult;
32917 }
32918
32919
32920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32921   int jresult ;
32922   int result;
32923
32924   result = (int)Dali::Actor::Property::SIZE;
32925   jresult = (int)result;
32926   return jresult;
32927 }
32928
32929
32930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32931   int jresult ;
32932   int result;
32933
32934   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32935   jresult = (int)result;
32936   return jresult;
32937 }
32938
32939
32940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32941   int jresult ;
32942   int result;
32943
32944   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32945   jresult = (int)result;
32946   return jresult;
32947 }
32948
32949
32950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32951   int jresult ;
32952   int result;
32953
32954   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32955   jresult = (int)result;
32956   return jresult;
32957 }
32958
32959
32960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32961   int jresult ;
32962   int result;
32963
32964   result = (int)Dali::Actor::Property::POSITION;
32965   jresult = (int)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32971   int jresult ;
32972   int result;
32973
32974   result = (int)Dali::Actor::Property::POSITION_X;
32975   jresult = (int)result;
32976   return jresult;
32977 }
32978
32979
32980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32981   int jresult ;
32982   int result;
32983
32984   result = (int)Dali::Actor::Property::POSITION_Y;
32985   jresult = (int)result;
32986   return jresult;
32987 }
32988
32989
32990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32991   int jresult ;
32992   int result;
32993
32994   result = (int)Dali::Actor::Property::POSITION_Z;
32995   jresult = (int)result;
32996   return jresult;
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33001   int jresult ;
33002   int result;
33003
33004   result = (int)Dali::Actor::Property::WORLD_POSITION;
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33011   int jresult ;
33012   int result;
33013
33014   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33015   jresult = (int)result;
33016   return jresult;
33017 }
33018
33019
33020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33021   int jresult ;
33022   int result;
33023
33024   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33025   jresult = (int)result;
33026   return jresult;
33027 }
33028
33029
33030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33031   int jresult ;
33032   int result;
33033
33034   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33035   jresult = (int)result;
33036   return jresult;
33037 }
33038
33039
33040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33041   int jresult ;
33042   int result;
33043
33044   result = (int)Dali::Actor::Property::ORIENTATION;
33045   jresult = (int)result;
33046   return jresult;
33047 }
33048
33049
33050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33051   int jresult ;
33052   int result;
33053
33054   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33055   jresult = (int)result;
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33061   int jresult ;
33062   int result;
33063
33064   result = (int)Dali::Actor::Property::SCALE;
33065   jresult = (int)result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33071   int jresult ;
33072   int result;
33073
33074   result = (int)Dali::Actor::Property::SCALE_X;
33075   jresult = (int)result;
33076   return jresult;
33077 }
33078
33079
33080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33081   int jresult ;
33082   int result;
33083
33084   result = (int)Dali::Actor::Property::SCALE_Y;
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33091   int jresult ;
33092   int result;
33093
33094   result = (int)Dali::Actor::Property::SCALE_Z;
33095   jresult = (int)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33101   int jresult ;
33102   int result;
33103
33104   result = (int)Dali::Actor::Property::WORLD_SCALE;
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33111   int jresult ;
33112   int result;
33113
33114   result = (int)Dali::Actor::Property::VISIBLE;
33115   jresult = (int)result;
33116   return jresult;
33117 }
33118
33119
33120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33121   int jresult ;
33122   int result;
33123
33124   result = (int)Dali::Actor::Property::COLOR;
33125   jresult = (int)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::COLOR_RED;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::COLOR_GREEN;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::COLOR_BLUE;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33161   int jresult ;
33162   int result;
33163
33164   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33165   jresult = (int)result;
33166   return jresult;
33167 }
33168
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33171   int jresult ;
33172   int result;
33173
33174   result = (int)Dali::Actor::Property::WORLD_COLOR;
33175   jresult = (int)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33181   int jresult ;
33182   int result;
33183
33184   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33185   jresult = (int)result;
33186   return jresult;
33187 }
33188
33189
33190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33191   int jresult ;
33192   int result;
33193
33194   result = (int)Dali::Actor::Property::NAME;
33195   jresult = (int)result;
33196   return jresult;
33197 }
33198
33199
33200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33201   int jresult ;
33202   int result;
33203
33204   result = (int)Dali::Actor::Property::SENSITIVE;
33205   jresult = (int)result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33211   int jresult ;
33212   int result;
33213
33214   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33215   jresult = (int)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33221   int jresult ;
33222   int result;
33223
33224   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33225   jresult = (int)result;
33226   return jresult;
33227 }
33228
33229
33230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33231   int jresult ;
33232   int result;
33233
33234   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33235   jresult = (int)result;
33236   return jresult;
33237 }
33238
33239
33240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33241   int jresult ;
33242   int result;
33243
33244   result = (int)Dali::Actor::Property::COLOR_MODE;
33245   jresult = (int)result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33251   int jresult ;
33252   int result;
33253
33254   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33255   jresult = (int)result;
33256   return jresult;
33257 }
33258
33259
33260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33261   int jresult ;
33262   int result;
33263
33264   result = (int)Dali::Actor::Property::DRAW_MODE;
33265   jresult = (int)result;
33266   return jresult;
33267 }
33268
33269
33270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33271   int jresult ;
33272   int result;
33273
33274   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33275   jresult = (int)result;
33276   return jresult;
33277 }
33278
33279
33280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33281   int jresult ;
33282   int result;
33283
33284   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33285   jresult = (int)result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33291   int jresult ;
33292   int result;
33293
33294   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33295   jresult = (int)result;
33296   return jresult;
33297 }
33298
33299
33300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33301   int jresult ;
33302   int result;
33303
33304   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33305   jresult = (int)result;
33306   return jresult;
33307 }
33308
33309
33310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33311   int jresult ;
33312   int result;
33313
33314   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33315   jresult = (int)result;
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33321   int jresult ;
33322   int result;
33323
33324   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33325   jresult = (int)result;
33326   return jresult;
33327 }
33328
33329
33330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33331   int jresult ;
33332   int result;
33333
33334   result = (int)Dali::Actor::Property::PADDING;
33335   jresult = (int)result;
33336   return jresult;
33337 }
33338
33339
33340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33341   int jresult ;
33342   int result;
33343
33344   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33345   jresult = (int)result;
33346   return jresult;
33347 }
33348
33349
33350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33351   int jresult ;
33352   int result;
33353
33354   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33355   jresult = (int)result;
33356   return jresult;
33357 }
33358
33359
33360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33361   int jresult ;
33362   int result;
33363
33364   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33365   jresult = (int)result;
33366   return jresult;
33367 }
33368
33369
33370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33371   int jresult ;
33372   int result;
33373
33374   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33375   jresult = (int)result;
33376   return jresult;
33377 }
33378
33379
33380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33381   void * jresult ;
33382   Dali::Actor::Property *result = 0 ;
33383
33384   {
33385     try {
33386       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33387     } catch (std::out_of_range& e) {
33388       {
33389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33390       };
33391     } catch (std::exception& e) {
33392       {
33393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33394       };
33395     } catch (Dali::DaliException e) {
33396       {
33397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33398       };
33399     } catch (...) {
33400       {
33401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33402       };
33403     }
33404   }
33405
33406   jresult = (void *)result;
33407   return jresult;
33408 }
33409
33410
33411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33412   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33413
33414   arg1 = (Dali::Actor::Property *)jarg1;
33415   {
33416     try {
33417       delete arg1;
33418     } catch (std::out_of_range& e) {
33419       {
33420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33421       };
33422     } catch (std::exception& e) {
33423       {
33424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33425       };
33426     } catch (Dali::DaliException e) {
33427       {
33428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33429       };
33430     } catch (...) {
33431       {
33432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33433       };
33434     }
33435   }
33436
33437 }
33438
33439
33440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33441   void * jresult ;
33442   Dali::Actor *result = 0 ;
33443
33444   {
33445     try {
33446       result = (Dali::Actor *)new Dali::Actor();
33447     } catch (std::out_of_range& e) {
33448       {
33449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33450       };
33451     } catch (std::exception& e) {
33452       {
33453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33454       };
33455     } catch (Dali::DaliException e) {
33456       {
33457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33458       };
33459     } catch (...) {
33460       {
33461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33462       };
33463     }
33464   }
33465
33466   jresult = (void *)result;
33467   return jresult;
33468 }
33469
33470
33471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33472   void * jresult ;
33473   Dali::Actor result;
33474
33475   {
33476     try {
33477       result = Dali::Actor::New();
33478     } catch (std::out_of_range& e) {
33479       {
33480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33481       };
33482     } catch (std::exception& e) {
33483       {
33484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33485       };
33486     } catch (Dali::DaliException e) {
33487       {
33488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33489       };
33490     } catch (...) {
33491       {
33492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33493       };
33494     }
33495   }
33496
33497   jresult = new Dali::Actor((const Dali::Actor &)result);
33498   return jresult;
33499 }
33500
33501
33502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33503   void * jresult ;
33504   Dali::BaseHandle arg1 ;
33505   Dali::BaseHandle *argp1 ;
33506   Dali::Actor result;
33507
33508   argp1 = (Dali::BaseHandle *)jarg1;
33509   if (!argp1) {
33510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33511     return 0;
33512   }
33513   arg1 = *argp1;
33514   {
33515     try {
33516       result = Dali::Actor::DownCast(arg1);
33517     } catch (std::out_of_range& e) {
33518       {
33519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33520       };
33521     } catch (std::exception& e) {
33522       {
33523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33524       };
33525     } catch (Dali::DaliException e) {
33526       {
33527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33528       };
33529     } catch (...) {
33530       {
33531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33532       };
33533     }
33534   }
33535
33536   jresult = new Dali::Actor((const Dali::Actor &)result);
33537   return jresult;
33538 }
33539
33540
33541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33543
33544   arg1 = (Dali::Actor *)jarg1;
33545   {
33546     try {
33547       delete arg1;
33548     } catch (std::out_of_range& e) {
33549       {
33550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33551       };
33552     } catch (std::exception& e) {
33553       {
33554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33555       };
33556     } catch (Dali::DaliException e) {
33557       {
33558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33559       };
33560     } catch (...) {
33561       {
33562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33563       };
33564     }
33565   }
33566
33567 }
33568
33569
33570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33571   void * jresult ;
33572   Dali::Actor *arg1 = 0 ;
33573   Dali::Actor *result = 0 ;
33574
33575   arg1 = (Dali::Actor *)jarg1;
33576   if (!arg1) {
33577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33578     return 0;
33579   }
33580   {
33581     try {
33582       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33583     } catch (std::out_of_range& e) {
33584       {
33585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33586       };
33587     } catch (std::exception& e) {
33588       {
33589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33590       };
33591     } catch (Dali::DaliException e) {
33592       {
33593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33594       };
33595     } catch (...) {
33596       {
33597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33598       };
33599     }
33600   }
33601
33602   jresult = (void *)result;
33603   return jresult;
33604 }
33605
33606
33607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33608   void * jresult ;
33609   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33610   Dali::Actor *arg2 = 0 ;
33611   Dali::Actor *result = 0 ;
33612
33613   arg1 = (Dali::Actor *)jarg1;
33614   arg2 = (Dali::Actor *)jarg2;
33615   if (!arg2) {
33616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33617     return 0;
33618   }
33619   {
33620     try {
33621       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33622     } catch (std::out_of_range& e) {
33623       {
33624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33625       };
33626     } catch (std::exception& e) {
33627       {
33628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33629       };
33630     } catch (Dali::DaliException e) {
33631       {
33632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33633       };
33634     } catch (...) {
33635       {
33636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33637       };
33638     }
33639   }
33640
33641   jresult = (void *)result;
33642   return jresult;
33643 }
33644
33645
33646 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33647   char * jresult ;
33648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33649   std::string *result = 0 ;
33650
33651   arg1 = (Dali::Actor *)jarg1;
33652   {
33653     try {
33654       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33655     } catch (std::out_of_range& e) {
33656       {
33657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33658       };
33659     } catch (std::exception& e) {
33660       {
33661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33662       };
33663     } catch (Dali::DaliException e) {
33664       {
33665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33666       };
33667     } catch (...) {
33668       {
33669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33670       };
33671     }
33672   }
33673
33674   jresult = SWIG_csharp_string_callback(result->c_str());
33675   return jresult;
33676 }
33677
33678
33679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33680   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33681   std::string *arg2 = 0 ;
33682
33683   arg1 = (Dali::Actor *)jarg1;
33684   if (!jarg2) {
33685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33686     return ;
33687   }
33688   std::string arg2_str(jarg2);
33689   arg2 = &arg2_str;
33690   {
33691     try {
33692       (arg1)->SetName((std::string const &)*arg2);
33693     } catch (std::out_of_range& e) {
33694       {
33695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33696       };
33697     } catch (std::exception& e) {
33698       {
33699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33700       };
33701     } catch (Dali::DaliException e) {
33702       {
33703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33704       };
33705     } catch (...) {
33706       {
33707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33708       };
33709     }
33710   }
33711
33712
33713   //argout typemap for const std::string&
33714
33715 }
33716
33717
33718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33719   unsigned int jresult ;
33720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33721   unsigned int result;
33722
33723   arg1 = (Dali::Actor *)jarg1;
33724   {
33725     try {
33726       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33727     } catch (std::out_of_range& e) {
33728       {
33729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33730       };
33731     } catch (std::exception& e) {
33732       {
33733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33734       };
33735     } catch (Dali::DaliException e) {
33736       {
33737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33738       };
33739     } catch (...) {
33740       {
33741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33742       };
33743     }
33744   }
33745
33746   jresult = result;
33747   return jresult;
33748 }
33749
33750
33751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33752   unsigned int jresult ;
33753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33754   bool result;
33755
33756   arg1 = (Dali::Actor *)jarg1;
33757   {
33758     try {
33759       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33760     } catch (std::out_of_range& e) {
33761       {
33762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33763       };
33764     } catch (std::exception& e) {
33765       {
33766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33767       };
33768     } catch (Dali::DaliException e) {
33769       {
33770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33771       };
33772     } catch (...) {
33773       {
33774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33775       };
33776     }
33777   }
33778
33779   jresult = result;
33780   return jresult;
33781 }
33782
33783
33784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33785   unsigned int jresult ;
33786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33787   bool result;
33788
33789   arg1 = (Dali::Actor *)jarg1;
33790   {
33791     try {
33792       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33793     } catch (std::out_of_range& e) {
33794       {
33795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (std::exception& e) {
33798       {
33799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33800       };
33801     } catch (Dali::DaliException e) {
33802       {
33803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33804       };
33805     } catch (...) {
33806       {
33807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33808       };
33809     }
33810   }
33811
33812   jresult = result;
33813   return jresult;
33814 }
33815
33816
33817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33818   unsigned int jresult ;
33819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33820   bool result;
33821
33822   arg1 = (Dali::Actor *)jarg1;
33823   {
33824     try {
33825       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33826     } catch (std::out_of_range& e) {
33827       {
33828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33829       };
33830     } catch (std::exception& e) {
33831       {
33832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33833       };
33834     } catch (Dali::DaliException e) {
33835       {
33836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33837       };
33838     } catch (...) {
33839       {
33840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33841       };
33842     }
33843   }
33844
33845   jresult = result;
33846   return jresult;
33847 }
33848
33849
33850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33851   void * jresult ;
33852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33853   Dali::Layer result;
33854
33855   arg1 = (Dali::Actor *)jarg1;
33856   {
33857     try {
33858       result = (arg1)->GetLayer();
33859     } catch (std::out_of_range& e) {
33860       {
33861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33862       };
33863     } catch (std::exception& e) {
33864       {
33865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33866       };
33867     } catch (Dali::DaliException e) {
33868       {
33869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33870       };
33871     } catch (...) {
33872       {
33873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33874       };
33875     }
33876   }
33877
33878   jresult = new Dali::Layer((const Dali::Layer &)result);
33879   return jresult;
33880 }
33881
33882
33883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33884   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33885   Dali::Actor arg2 ;
33886   Dali::Actor *argp2 ;
33887
33888   arg1 = (Dali::Actor *)jarg1;
33889   argp2 = (Dali::Actor *)jarg2;
33890   if (!argp2) {
33891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33892     return ;
33893   }
33894   arg2 = *argp2;
33895   {
33896     try {
33897       (arg1)->Add(arg2);
33898     } catch (std::out_of_range& e) {
33899       {
33900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33901       };
33902     } catch (std::exception& e) {
33903       {
33904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33905       };
33906     } catch (Dali::DaliException e) {
33907       {
33908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33909       };
33910     } catch (...) {
33911       {
33912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33913       };
33914     }
33915   }
33916
33917 }
33918
33919
33920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33922   Dali::Actor arg2 ;
33923   Dali::Actor *argp2 ;
33924
33925   arg1 = (Dali::Actor *)jarg1;
33926   argp2 = (Dali::Actor *)jarg2;
33927   if (!argp2) {
33928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33929     return ;
33930   }
33931   arg2 = *argp2;
33932   {
33933     try {
33934       (arg1)->Remove(arg2);
33935     } catch (std::out_of_range& e) {
33936       {
33937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33938       };
33939     } catch (std::exception& e) {
33940       {
33941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33942       };
33943     } catch (Dali::DaliException e) {
33944       {
33945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33946       };
33947     } catch (...) {
33948       {
33949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33950       };
33951     }
33952   }
33953
33954 }
33955
33956
33957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33959
33960   arg1 = (Dali::Actor *)jarg1;
33961   {
33962     try {
33963       (arg1)->Unparent();
33964     } catch (std::out_of_range& e) {
33965       {
33966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33967       };
33968     } catch (std::exception& e) {
33969       {
33970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33971       };
33972     } catch (Dali::DaliException e) {
33973       {
33974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33975       };
33976     } catch (...) {
33977       {
33978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33979       };
33980     }
33981   }
33982
33983 }
33984
33985
33986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33987   unsigned int jresult ;
33988   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33989   unsigned int result;
33990
33991   arg1 = (Dali::Actor *)jarg1;
33992   {
33993     try {
33994       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33995     } catch (std::out_of_range& e) {
33996       {
33997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33998       };
33999     } catch (std::exception& e) {
34000       {
34001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34002       };
34003     } catch (Dali::DaliException e) {
34004       {
34005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34006       };
34007     } catch (...) {
34008       {
34009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34010       };
34011     }
34012   }
34013
34014   jresult = result;
34015   return jresult;
34016 }
34017
34018
34019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34020   void * jresult ;
34021   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34022   unsigned int arg2 ;
34023   Dali::Actor result;
34024
34025   arg1 = (Dali::Actor *)jarg1;
34026   arg2 = (unsigned int)jarg2;
34027   {
34028     try {
34029       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34030     } catch (std::out_of_range& e) {
34031       {
34032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34033       };
34034     } catch (std::exception& e) {
34035       {
34036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34037       };
34038     } catch (Dali::DaliException e) {
34039       {
34040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34041       };
34042     } catch (...) {
34043       {
34044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34045       };
34046     }
34047   }
34048
34049   jresult = new Dali::Actor((const Dali::Actor &)result);
34050   return jresult;
34051 }
34052
34053
34054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34055   void * jresult ;
34056   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34057   std::string *arg2 = 0 ;
34058   Dali::Actor result;
34059
34060   arg1 = (Dali::Actor *)jarg1;
34061   if (!jarg2) {
34062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34063     return 0;
34064   }
34065   std::string arg2_str(jarg2);
34066   arg2 = &arg2_str;
34067   {
34068     try {
34069       result = (arg1)->FindChildByName((std::string const &)*arg2);
34070     } catch (std::out_of_range& e) {
34071       {
34072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34073       };
34074     } catch (std::exception& e) {
34075       {
34076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34077       };
34078     } catch (Dali::DaliException e) {
34079       {
34080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34081       };
34082     } catch (...) {
34083       {
34084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34085       };
34086     }
34087   }
34088
34089   jresult = new Dali::Actor((const Dali::Actor &)result);
34090
34091   //argout typemap for const std::string&
34092
34093   return jresult;
34094 }
34095
34096
34097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34098   void * jresult ;
34099   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34100   unsigned int arg2 ;
34101   Dali::Actor result;
34102
34103   arg1 = (Dali::Actor *)jarg1;
34104   arg2 = (unsigned int)jarg2;
34105   {
34106     try {
34107       result = (arg1)->FindChildById(arg2);
34108     } catch (std::out_of_range& e) {
34109       {
34110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34111       };
34112     } catch (std::exception& e) {
34113       {
34114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34115       };
34116     } catch (Dali::DaliException e) {
34117       {
34118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34119       };
34120     } catch (...) {
34121       {
34122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34123       };
34124     }
34125   }
34126
34127   jresult = new Dali::Actor((const Dali::Actor &)result);
34128   return jresult;
34129 }
34130
34131
34132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34133   void * jresult ;
34134   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34135   Dali::Actor result;
34136
34137   arg1 = (Dali::Actor *)jarg1;
34138   {
34139     try {
34140       result = ((Dali::Actor const *)arg1)->GetParent();
34141     } catch (std::out_of_range& e) {
34142       {
34143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34144       };
34145     } catch (std::exception& e) {
34146       {
34147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34148       };
34149     } catch (Dali::DaliException e) {
34150       {
34151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34152       };
34153     } catch (...) {
34154       {
34155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34156       };
34157     }
34158   }
34159
34160   jresult = new Dali::Actor((const Dali::Actor &)result);
34161   return jresult;
34162 }
34163
34164
34165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34166   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34167   Dali::Vector3 *arg2 = 0 ;
34168
34169   arg1 = (Dali::Actor *)jarg1;
34170   arg2 = (Dali::Vector3 *)jarg2;
34171   if (!arg2) {
34172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34173     return ;
34174   }
34175   {
34176     try {
34177       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34178     } catch (std::out_of_range& e) {
34179       {
34180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34181       };
34182     } catch (std::exception& e) {
34183       {
34184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34185       };
34186     } catch (Dali::DaliException e) {
34187       {
34188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34189       };
34190     } catch (...) {
34191       {
34192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34193       };
34194     }
34195   }
34196
34197 }
34198
34199
34200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34201   void * jresult ;
34202   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34203   Dali::Vector3 result;
34204
34205   arg1 = (Dali::Actor *)jarg1;
34206   {
34207     try {
34208       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34209     } catch (std::out_of_range& e) {
34210       {
34211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34212       };
34213     } catch (std::exception& e) {
34214       {
34215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34216       };
34217     } catch (Dali::DaliException e) {
34218       {
34219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34220       };
34221     } catch (...) {
34222       {
34223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34224       };
34225     }
34226   }
34227
34228   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34229   return jresult;
34230 }
34231
34232
34233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34234   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34235   Dali::Vector3 *arg2 = 0 ;
34236
34237   arg1 = (Dali::Actor *)jarg1;
34238   arg2 = (Dali::Vector3 *)jarg2;
34239   if (!arg2) {
34240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34241     return ;
34242   }
34243   {
34244     try {
34245       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34246     } catch (std::out_of_range& e) {
34247       {
34248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34249       };
34250     } catch (std::exception& e) {
34251       {
34252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34253       };
34254     } catch (Dali::DaliException e) {
34255       {
34256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34257       };
34258     } catch (...) {
34259       {
34260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34261       };
34262     }
34263   }
34264
34265 }
34266
34267
34268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34269   void * jresult ;
34270   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34271   Dali::Vector3 result;
34272
34273   arg1 = (Dali::Actor *)jarg1;
34274   {
34275     try {
34276       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34277     } catch (std::out_of_range& e) {
34278       {
34279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34280       };
34281     } catch (std::exception& e) {
34282       {
34283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34284       };
34285     } catch (Dali::DaliException e) {
34286       {
34287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34288       };
34289     } catch (...) {
34290       {
34291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34292       };
34293     }
34294   }
34295
34296   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34297   return jresult;
34298 }
34299
34300
34301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34302   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34303   float arg2 ;
34304   float arg3 ;
34305
34306   arg1 = (Dali::Actor *)jarg1;
34307   arg2 = (float)jarg2;
34308   arg3 = (float)jarg3;
34309   {
34310     try {
34311       (arg1)->SetSize(arg2,arg3);
34312     } catch (std::out_of_range& e) {
34313       {
34314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34315       };
34316     } catch (std::exception& e) {
34317       {
34318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34319       };
34320     } catch (Dali::DaliException e) {
34321       {
34322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34323       };
34324     } catch (...) {
34325       {
34326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34327       };
34328     }
34329   }
34330
34331 }
34332
34333
34334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34335   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34336   float arg2 ;
34337   float arg3 ;
34338   float arg4 ;
34339
34340   arg1 = (Dali::Actor *)jarg1;
34341   arg2 = (float)jarg2;
34342   arg3 = (float)jarg3;
34343   arg4 = (float)jarg4;
34344   {
34345     try {
34346       (arg1)->SetSize(arg2,arg3,arg4);
34347     } catch (std::out_of_range& e) {
34348       {
34349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34350       };
34351     } catch (std::exception& e) {
34352       {
34353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34354       };
34355     } catch (Dali::DaliException e) {
34356       {
34357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34358       };
34359     } catch (...) {
34360       {
34361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34362       };
34363     }
34364   }
34365
34366 }
34367
34368
34369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34370   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34371   Dali::Vector2 *arg2 = 0 ;
34372
34373   arg1 = (Dali::Actor *)jarg1;
34374   arg2 = (Dali::Vector2 *)jarg2;
34375   if (!arg2) {
34376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34377     return ;
34378   }
34379   {
34380     try {
34381       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34382     } catch (std::out_of_range& e) {
34383       {
34384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34385       };
34386     } catch (std::exception& e) {
34387       {
34388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34389       };
34390     } catch (Dali::DaliException e) {
34391       {
34392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34393       };
34394     } catch (...) {
34395       {
34396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34397       };
34398     }
34399   }
34400
34401 }
34402
34403
34404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34405   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34406   Dali::Vector3 *arg2 = 0 ;
34407
34408   arg1 = (Dali::Actor *)jarg1;
34409   arg2 = (Dali::Vector3 *)jarg2;
34410   if (!arg2) {
34411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34412     return ;
34413   }
34414   {
34415     try {
34416       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34417     } catch (std::out_of_range& e) {
34418       {
34419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34420       };
34421     } catch (std::exception& e) {
34422       {
34423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34424       };
34425     } catch (Dali::DaliException e) {
34426       {
34427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34428       };
34429     } catch (...) {
34430       {
34431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34432       };
34433     }
34434   }
34435
34436 }
34437
34438
34439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34440   void * jresult ;
34441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34442   Dali::Vector3 result;
34443
34444   arg1 = (Dali::Actor *)jarg1;
34445   {
34446     try {
34447       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34448     } catch (std::out_of_range& e) {
34449       {
34450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34451       };
34452     } catch (std::exception& e) {
34453       {
34454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34455       };
34456     } catch (Dali::DaliException e) {
34457       {
34458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34459       };
34460     } catch (...) {
34461       {
34462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34463       };
34464     }
34465   }
34466
34467   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34468   return jresult;
34469 }
34470
34471
34472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34473   void * jresult ;
34474   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34475   Dali::Vector3 result;
34476
34477   arg1 = (Dali::Actor *)jarg1;
34478   {
34479     try {
34480       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34481     } catch (std::out_of_range& e) {
34482       {
34483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34484       };
34485     } catch (std::exception& e) {
34486       {
34487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34488       };
34489     } catch (Dali::DaliException e) {
34490       {
34491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34492       };
34493     } catch (...) {
34494       {
34495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34496       };
34497     }
34498   }
34499
34500   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34501   return jresult;
34502 }
34503
34504
34505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34506   void * jresult ;
34507   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34508   Dali::Vector3 result;
34509
34510   arg1 = (Dali::Actor *)jarg1;
34511   {
34512     try {
34513       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34514     } catch (std::out_of_range& e) {
34515       {
34516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34517       };
34518     } catch (std::exception& e) {
34519       {
34520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34521       };
34522     } catch (Dali::DaliException e) {
34523       {
34524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34525       };
34526     } catch (...) {
34527       {
34528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34529       };
34530     }
34531   }
34532
34533   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34534   return jresult;
34535 }
34536
34537
34538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34540   float arg2 ;
34541   float arg3 ;
34542
34543   arg1 = (Dali::Actor *)jarg1;
34544   arg2 = (float)jarg2;
34545   arg3 = (float)jarg3;
34546   {
34547     try {
34548       (arg1)->SetPosition(arg2,arg3);
34549     } catch (std::out_of_range& e) {
34550       {
34551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34552       };
34553     } catch (std::exception& e) {
34554       {
34555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34556       };
34557     } catch (Dali::DaliException e) {
34558       {
34559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34560       };
34561     } catch (...) {
34562       {
34563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34564       };
34565     }
34566   }
34567
34568 }
34569
34570
34571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34573   float arg2 ;
34574   float arg3 ;
34575   float arg4 ;
34576
34577   arg1 = (Dali::Actor *)jarg1;
34578   arg2 = (float)jarg2;
34579   arg3 = (float)jarg3;
34580   arg4 = (float)jarg4;
34581   {
34582     try {
34583       (arg1)->SetPosition(arg2,arg3,arg4);
34584     } catch (std::out_of_range& e) {
34585       {
34586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34587       };
34588     } catch (std::exception& e) {
34589       {
34590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34591       };
34592     } catch (Dali::DaliException e) {
34593       {
34594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34595       };
34596     } catch (...) {
34597       {
34598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34599       };
34600     }
34601   }
34602
34603 }
34604
34605
34606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34607   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34608   Dali::Vector3 *arg2 = 0 ;
34609
34610   arg1 = (Dali::Actor *)jarg1;
34611   arg2 = (Dali::Vector3 *)jarg2;
34612   if (!arg2) {
34613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34614     return ;
34615   }
34616   {
34617     try {
34618       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34619     } catch (std::out_of_range& e) {
34620       {
34621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34622       };
34623     } catch (std::exception& e) {
34624       {
34625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34626       };
34627     } catch (Dali::DaliException e) {
34628       {
34629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34630       };
34631     } catch (...) {
34632       {
34633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34634       };
34635     }
34636   }
34637
34638 }
34639
34640
34641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34642   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34643   float arg2 ;
34644
34645   arg1 = (Dali::Actor *)jarg1;
34646   arg2 = (float)jarg2;
34647   {
34648     try {
34649       (arg1)->SetX(arg2);
34650     } catch (std::out_of_range& e) {
34651       {
34652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34653       };
34654     } catch (std::exception& e) {
34655       {
34656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34657       };
34658     } catch (Dali::DaliException e) {
34659       {
34660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34661       };
34662     } catch (...) {
34663       {
34664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34665       };
34666     }
34667   }
34668
34669 }
34670
34671
34672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34674   float arg2 ;
34675
34676   arg1 = (Dali::Actor *)jarg1;
34677   arg2 = (float)jarg2;
34678   {
34679     try {
34680       (arg1)->SetY(arg2);
34681     } catch (std::out_of_range& e) {
34682       {
34683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34684       };
34685     } catch (std::exception& e) {
34686       {
34687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34688       };
34689     } catch (Dali::DaliException e) {
34690       {
34691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34692       };
34693     } catch (...) {
34694       {
34695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34696       };
34697     }
34698   }
34699
34700 }
34701
34702
34703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34705   float arg2 ;
34706
34707   arg1 = (Dali::Actor *)jarg1;
34708   arg2 = (float)jarg2;
34709   {
34710     try {
34711       (arg1)->SetZ(arg2);
34712     } catch (std::out_of_range& e) {
34713       {
34714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34715       };
34716     } catch (std::exception& e) {
34717       {
34718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34719       };
34720     } catch (Dali::DaliException e) {
34721       {
34722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34723       };
34724     } catch (...) {
34725       {
34726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34727       };
34728     }
34729   }
34730
34731 }
34732
34733
34734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34736   Dali::Vector3 *arg2 = 0 ;
34737
34738   arg1 = (Dali::Actor *)jarg1;
34739   arg2 = (Dali::Vector3 *)jarg2;
34740   if (!arg2) {
34741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34742     return ;
34743   }
34744   {
34745     try {
34746       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34747     } catch (std::out_of_range& e) {
34748       {
34749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34750       };
34751     } catch (std::exception& e) {
34752       {
34753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34754       };
34755     } catch (Dali::DaliException e) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34758       };
34759     } catch (...) {
34760       {
34761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34762       };
34763     }
34764   }
34765
34766 }
34767
34768
34769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34770   void * jresult ;
34771   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34772   Dali::Vector3 result;
34773
34774   arg1 = (Dali::Actor *)jarg1;
34775   {
34776     try {
34777       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34778     } catch (std::out_of_range& e) {
34779       {
34780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34781       };
34782     } catch (std::exception& e) {
34783       {
34784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34785       };
34786     } catch (Dali::DaliException e) {
34787       {
34788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34789       };
34790     } catch (...) {
34791       {
34792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34793       };
34794     }
34795   }
34796
34797   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34798   return jresult;
34799 }
34800
34801
34802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34803   void * jresult ;
34804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34805   Dali::Vector3 result;
34806
34807   arg1 = (Dali::Actor *)jarg1;
34808   {
34809     try {
34810       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34811     } catch (std::out_of_range& e) {
34812       {
34813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34814       };
34815     } catch (std::exception& e) {
34816       {
34817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34818       };
34819     } catch (Dali::DaliException e) {
34820       {
34821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34822       };
34823     } catch (...) {
34824       {
34825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34826       };
34827     }
34828   }
34829
34830   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34831   return jresult;
34832 }
34833
34834
34835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34836   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34837   bool arg2 ;
34838
34839   arg1 = (Dali::Actor *)jarg1;
34840   arg2 = jarg2 ? true : false;
34841   {
34842     try {
34843       (arg1)->SetInheritPosition(arg2);
34844     } catch (std::out_of_range& e) {
34845       {
34846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34847       };
34848     } catch (std::exception& e) {
34849       {
34850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34851       };
34852     } catch (Dali::DaliException e) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34855       };
34856     } catch (...) {
34857       {
34858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34859       };
34860     }
34861   }
34862
34863 }
34864
34865
34866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34867   int jresult ;
34868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34869   Dali::PositionInheritanceMode result;
34870
34871   arg1 = (Dali::Actor *)jarg1;
34872   {
34873     try {
34874       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34875     } catch (std::out_of_range& e) {
34876       {
34877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34878       };
34879     } catch (std::exception& e) {
34880       {
34881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34882       };
34883     } catch (Dali::DaliException e) {
34884       {
34885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34886       };
34887     } catch (...) {
34888       {
34889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34890       };
34891     }
34892   }
34893
34894   jresult = (int)result;
34895   return jresult;
34896 }
34897
34898
34899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34900   unsigned int jresult ;
34901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34902   bool result;
34903
34904   arg1 = (Dali::Actor *)jarg1;
34905   {
34906     try {
34907       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34908     } catch (std::out_of_range& e) {
34909       {
34910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34911       };
34912     } catch (std::exception& e) {
34913       {
34914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34915       };
34916     } catch (Dali::DaliException e) {
34917       {
34918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34919       };
34920     } catch (...) {
34921       {
34922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34923       };
34924     }
34925   }
34926
34927   jresult = result;
34928   return jresult;
34929 }
34930
34931
34932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34934   Dali::Degree *arg2 = 0 ;
34935   Dali::Vector3 *arg3 = 0 ;
34936
34937   arg1 = (Dali::Actor *)jarg1;
34938   arg2 = (Dali::Degree *)jarg2;
34939   if (!arg2) {
34940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34941     return ;
34942   }
34943   arg3 = (Dali::Vector3 *)jarg3;
34944   if (!arg3) {
34945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34946     return ;
34947   }
34948   {
34949     try {
34950       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34951     } catch (std::out_of_range& e) {
34952       {
34953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34954       };
34955     } catch (std::exception& e) {
34956       {
34957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34958       };
34959     } catch (Dali::DaliException e) {
34960       {
34961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34962       };
34963     } catch (...) {
34964       {
34965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34966       };
34967     }
34968   }
34969
34970 }
34971
34972
34973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34974   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34975   Dali::Radian *arg2 = 0 ;
34976   Dali::Vector3 *arg3 = 0 ;
34977
34978   arg1 = (Dali::Actor *)jarg1;
34979   arg2 = (Dali::Radian *)jarg2;
34980   if (!arg2) {
34981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34982     return ;
34983   }
34984   arg3 = (Dali::Vector3 *)jarg3;
34985   if (!arg3) {
34986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34987     return ;
34988   }
34989   {
34990     try {
34991       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34992     } catch (std::out_of_range& e) {
34993       {
34994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34995       };
34996     } catch (std::exception& e) {
34997       {
34998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34999       };
35000     } catch (Dali::DaliException e) {
35001       {
35002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35003       };
35004     } catch (...) {
35005       {
35006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35007       };
35008     }
35009   }
35010
35011 }
35012
35013
35014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35016   Dali::Quaternion *arg2 = 0 ;
35017
35018   arg1 = (Dali::Actor *)jarg1;
35019   arg2 = (Dali::Quaternion *)jarg2;
35020   if (!arg2) {
35021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35022     return ;
35023   }
35024   {
35025     try {
35026       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35027     } catch (std::out_of_range& e) {
35028       {
35029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35030       };
35031     } catch (std::exception& e) {
35032       {
35033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35034       };
35035     } catch (Dali::DaliException e) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35038       };
35039     } catch (...) {
35040       {
35041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35042       };
35043     }
35044   }
35045
35046 }
35047
35048
35049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35051   Dali::Degree *arg2 = 0 ;
35052   Dali::Vector3 *arg3 = 0 ;
35053
35054   arg1 = (Dali::Actor *)jarg1;
35055   arg2 = (Dali::Degree *)jarg2;
35056   if (!arg2) {
35057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35058     return ;
35059   }
35060   arg3 = (Dali::Vector3 *)jarg3;
35061   if (!arg3) {
35062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35063     return ;
35064   }
35065   {
35066     try {
35067       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35068     } catch (std::out_of_range& e) {
35069       {
35070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35071       };
35072     } catch (std::exception& e) {
35073       {
35074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35075       };
35076     } catch (Dali::DaliException e) {
35077       {
35078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35079       };
35080     } catch (...) {
35081       {
35082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35083       };
35084     }
35085   }
35086
35087 }
35088
35089
35090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35092   Dali::Radian *arg2 = 0 ;
35093   Dali::Vector3 *arg3 = 0 ;
35094
35095   arg1 = (Dali::Actor *)jarg1;
35096   arg2 = (Dali::Radian *)jarg2;
35097   if (!arg2) {
35098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35099     return ;
35100   }
35101   arg3 = (Dali::Vector3 *)jarg3;
35102   if (!arg3) {
35103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35104     return ;
35105   }
35106   {
35107     try {
35108       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35109     } catch (std::out_of_range& e) {
35110       {
35111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35112       };
35113     } catch (std::exception& e) {
35114       {
35115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35116       };
35117     } catch (Dali::DaliException e) {
35118       {
35119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35120       };
35121     } catch (...) {
35122       {
35123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35124       };
35125     }
35126   }
35127
35128 }
35129
35130
35131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35132   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35133   Dali::Quaternion *arg2 = 0 ;
35134
35135   arg1 = (Dali::Actor *)jarg1;
35136   arg2 = (Dali::Quaternion *)jarg2;
35137   if (!arg2) {
35138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35139     return ;
35140   }
35141   {
35142     try {
35143       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35144     } catch (std::out_of_range& e) {
35145       {
35146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35147       };
35148     } catch (std::exception& e) {
35149       {
35150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35151       };
35152     } catch (Dali::DaliException e) {
35153       {
35154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35155       };
35156     } catch (...) {
35157       {
35158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35159       };
35160     }
35161   }
35162
35163 }
35164
35165
35166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35167   void * jresult ;
35168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35169   Dali::Quaternion result;
35170
35171   arg1 = (Dali::Actor *)jarg1;
35172   {
35173     try {
35174       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35175     } catch (std::out_of_range& e) {
35176       {
35177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35178       };
35179     } catch (std::exception& e) {
35180       {
35181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35182       };
35183     } catch (Dali::DaliException e) {
35184       {
35185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35186       };
35187     } catch (...) {
35188       {
35189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35190       };
35191     }
35192   }
35193
35194   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35195   return jresult;
35196 }
35197
35198
35199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35200   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35201   bool arg2 ;
35202
35203   arg1 = (Dali::Actor *)jarg1;
35204   arg2 = jarg2 ? true : false;
35205   {
35206     try {
35207       (arg1)->SetInheritOrientation(arg2);
35208     } catch (std::out_of_range& e) {
35209       {
35210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35211       };
35212     } catch (std::exception& e) {
35213       {
35214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35215       };
35216     } catch (Dali::DaliException e) {
35217       {
35218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35219       };
35220     } catch (...) {
35221       {
35222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35223       };
35224     }
35225   }
35226
35227 }
35228
35229
35230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35231   unsigned int jresult ;
35232   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35233   bool result;
35234
35235   arg1 = (Dali::Actor *)jarg1;
35236   {
35237     try {
35238       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35239     } catch (std::out_of_range& e) {
35240       {
35241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35242       };
35243     } catch (std::exception& e) {
35244       {
35245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35246       };
35247     } catch (Dali::DaliException e) {
35248       {
35249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35250       };
35251     } catch (...) {
35252       {
35253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35254       };
35255     }
35256   }
35257
35258   jresult = result;
35259   return jresult;
35260 }
35261
35262
35263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35264   void * jresult ;
35265   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35266   Dali::Quaternion result;
35267
35268   arg1 = (Dali::Actor *)jarg1;
35269   {
35270     try {
35271       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35272     } catch (std::out_of_range& e) {
35273       {
35274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35275       };
35276     } catch (std::exception& e) {
35277       {
35278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35279       };
35280     } catch (Dali::DaliException e) {
35281       {
35282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35283       };
35284     } catch (...) {
35285       {
35286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35287       };
35288     }
35289   }
35290
35291   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35292   return jresult;
35293 }
35294
35295
35296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35297   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35298   float arg2 ;
35299
35300   arg1 = (Dali::Actor *)jarg1;
35301   arg2 = (float)jarg2;
35302   {
35303     try {
35304       (arg1)->SetScale(arg2);
35305     } catch (std::out_of_range& e) {
35306       {
35307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35308       };
35309     } catch (std::exception& e) {
35310       {
35311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35312       };
35313     } catch (Dali::DaliException e) {
35314       {
35315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35316       };
35317     } catch (...) {
35318       {
35319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35320       };
35321     }
35322   }
35323
35324 }
35325
35326
35327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35328   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35329   float arg2 ;
35330   float arg3 ;
35331   float arg4 ;
35332
35333   arg1 = (Dali::Actor *)jarg1;
35334   arg2 = (float)jarg2;
35335   arg3 = (float)jarg3;
35336   arg4 = (float)jarg4;
35337   {
35338     try {
35339       (arg1)->SetScale(arg2,arg3,arg4);
35340     } catch (std::out_of_range& e) {
35341       {
35342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35343       };
35344     } catch (std::exception& e) {
35345       {
35346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35347       };
35348     } catch (Dali::DaliException e) {
35349       {
35350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35351       };
35352     } catch (...) {
35353       {
35354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35355       };
35356     }
35357   }
35358
35359 }
35360
35361
35362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35363   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35364   Dali::Vector3 *arg2 = 0 ;
35365
35366   arg1 = (Dali::Actor *)jarg1;
35367   arg2 = (Dali::Vector3 *)jarg2;
35368   if (!arg2) {
35369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35370     return ;
35371   }
35372   {
35373     try {
35374       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35375     } catch (std::out_of_range& e) {
35376       {
35377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35378       };
35379     } catch (std::exception& e) {
35380       {
35381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35382       };
35383     } catch (Dali::DaliException e) {
35384       {
35385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35386       };
35387     } catch (...) {
35388       {
35389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35390       };
35391     }
35392   }
35393
35394 }
35395
35396
35397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35398   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35399   Dali::Vector3 *arg2 = 0 ;
35400
35401   arg1 = (Dali::Actor *)jarg1;
35402   arg2 = (Dali::Vector3 *)jarg2;
35403   if (!arg2) {
35404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35405     return ;
35406   }
35407   {
35408     try {
35409       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35410     } catch (std::out_of_range& e) {
35411       {
35412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35413       };
35414     } catch (std::exception& e) {
35415       {
35416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35417       };
35418     } catch (Dali::DaliException e) {
35419       {
35420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35421       };
35422     } catch (...) {
35423       {
35424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35425       };
35426     }
35427   }
35428
35429 }
35430
35431
35432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35433   void * jresult ;
35434   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35435   Dali::Vector3 result;
35436
35437   arg1 = (Dali::Actor *)jarg1;
35438   {
35439     try {
35440       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35441     } catch (std::out_of_range& e) {
35442       {
35443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35444       };
35445     } catch (std::exception& e) {
35446       {
35447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35448       };
35449     } catch (Dali::DaliException e) {
35450       {
35451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35452       };
35453     } catch (...) {
35454       {
35455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35456       };
35457     }
35458   }
35459
35460   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35461   return jresult;
35462 }
35463
35464
35465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35466   void * jresult ;
35467   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35468   Dali::Vector3 result;
35469
35470   arg1 = (Dali::Actor *)jarg1;
35471   {
35472     try {
35473       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35474     } catch (std::out_of_range& e) {
35475       {
35476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35477       };
35478     } catch (std::exception& e) {
35479       {
35480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35481       };
35482     } catch (Dali::DaliException e) {
35483       {
35484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35485       };
35486     } catch (...) {
35487       {
35488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35489       };
35490     }
35491   }
35492
35493   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35494   return jresult;
35495 }
35496
35497
35498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35499   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35500   bool arg2 ;
35501
35502   arg1 = (Dali::Actor *)jarg1;
35503   arg2 = jarg2 ? true : false;
35504   {
35505     try {
35506       (arg1)->SetInheritScale(arg2);
35507     } catch (std::out_of_range& e) {
35508       {
35509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35510       };
35511     } catch (std::exception& e) {
35512       {
35513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35514       };
35515     } catch (Dali::DaliException e) {
35516       {
35517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35518       };
35519     } catch (...) {
35520       {
35521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35522       };
35523     }
35524   }
35525
35526 }
35527
35528
35529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35530   unsigned int jresult ;
35531   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35532   bool result;
35533
35534   arg1 = (Dali::Actor *)jarg1;
35535   {
35536     try {
35537       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35538     } catch (std::out_of_range& e) {
35539       {
35540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35541       };
35542     } catch (std::exception& e) {
35543       {
35544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35545       };
35546     } catch (Dali::DaliException e) {
35547       {
35548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35549       };
35550     } catch (...) {
35551       {
35552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35553       };
35554     }
35555   }
35556
35557   jresult = result;
35558   return jresult;
35559 }
35560
35561
35562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35563   void * jresult ;
35564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35565   Dali::Matrix result;
35566
35567   arg1 = (Dali::Actor *)jarg1;
35568   {
35569     try {
35570       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35571     } catch (std::out_of_range& e) {
35572       {
35573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35574       };
35575     } catch (std::exception& e) {
35576       {
35577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35578       };
35579     } catch (Dali::DaliException e) {
35580       {
35581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35582       };
35583     } catch (...) {
35584       {
35585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35586       };
35587     }
35588   }
35589
35590   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35591   return jresult;
35592 }
35593
35594
35595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35597   bool arg2 ;
35598
35599   arg1 = (Dali::Actor *)jarg1;
35600   arg2 = jarg2 ? true : false;
35601   {
35602     try {
35603       (arg1)->SetVisible(arg2);
35604     } catch (std::out_of_range& e) {
35605       {
35606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35607       };
35608     } catch (std::exception& e) {
35609       {
35610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35611       };
35612     } catch (Dali::DaliException e) {
35613       {
35614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35615       };
35616     } catch (...) {
35617       {
35618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35619       };
35620     }
35621   }
35622
35623 }
35624
35625
35626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35627   unsigned int jresult ;
35628   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35629   bool result;
35630
35631   arg1 = (Dali::Actor *)jarg1;
35632   {
35633     try {
35634       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35635     } catch (std::out_of_range& e) {
35636       {
35637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35638       };
35639     } catch (std::exception& e) {
35640       {
35641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35642       };
35643     } catch (Dali::DaliException e) {
35644       {
35645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35646       };
35647     } catch (...) {
35648       {
35649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35650       };
35651     }
35652   }
35653
35654   jresult = result;
35655   return jresult;
35656 }
35657
35658
35659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35660   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35661   float arg2 ;
35662
35663   arg1 = (Dali::Actor *)jarg1;
35664   arg2 = (float)jarg2;
35665   {
35666     try {
35667       (arg1)->SetOpacity(arg2);
35668     } catch (std::out_of_range& e) {
35669       {
35670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35671       };
35672     } catch (std::exception& e) {
35673       {
35674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35675       };
35676     } catch (Dali::DaliException e) {
35677       {
35678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35679       };
35680     } catch (...) {
35681       {
35682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35683       };
35684     }
35685   }
35686
35687 }
35688
35689
35690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35691   float jresult ;
35692   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35693   float result;
35694
35695   arg1 = (Dali::Actor *)jarg1;
35696   {
35697     try {
35698       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35699     } catch (std::out_of_range& e) {
35700       {
35701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35702       };
35703     } catch (std::exception& e) {
35704       {
35705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35706       };
35707     } catch (Dali::DaliException e) {
35708       {
35709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35710       };
35711     } catch (...) {
35712       {
35713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35714       };
35715     }
35716   }
35717
35718   jresult = result;
35719   return jresult;
35720 }
35721
35722
35723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35725   Dali::Vector4 *arg2 = 0 ;
35726
35727   arg1 = (Dali::Actor *)jarg1;
35728   arg2 = (Dali::Vector4 *)jarg2;
35729   if (!arg2) {
35730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35731     return ;
35732   }
35733   {
35734     try {
35735       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35736     } catch (std::out_of_range& e) {
35737       {
35738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35739       };
35740     } catch (std::exception& e) {
35741       {
35742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35743       };
35744     } catch (Dali::DaliException e) {
35745       {
35746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35747       };
35748     } catch (...) {
35749       {
35750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35751       };
35752     }
35753   }
35754
35755 }
35756
35757
35758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35759   void * jresult ;
35760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35761   Dali::Vector4 result;
35762
35763   arg1 = (Dali::Actor *)jarg1;
35764   {
35765     try {
35766       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35767     } catch (std::out_of_range& e) {
35768       {
35769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35770       };
35771     } catch (std::exception& e) {
35772       {
35773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35774       };
35775     } catch (Dali::DaliException e) {
35776       {
35777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35778       };
35779     } catch (...) {
35780       {
35781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35782       };
35783     }
35784   }
35785
35786   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35787   return jresult;
35788 }
35789
35790
35791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35792   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35793   Dali::ColorMode arg2 ;
35794
35795   arg1 = (Dali::Actor *)jarg1;
35796   arg2 = (Dali::ColorMode)jarg2;
35797   {
35798     try {
35799       (arg1)->SetColorMode(arg2);
35800     } catch (std::out_of_range& e) {
35801       {
35802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35803       };
35804     } catch (std::exception& e) {
35805       {
35806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35807       };
35808     } catch (Dali::DaliException e) {
35809       {
35810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35811       };
35812     } catch (...) {
35813       {
35814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35815       };
35816     }
35817   }
35818
35819 }
35820
35821
35822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35823   int jresult ;
35824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35825   Dali::ColorMode result;
35826
35827   arg1 = (Dali::Actor *)jarg1;
35828   {
35829     try {
35830       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35831     } catch (std::out_of_range& e) {
35832       {
35833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35834       };
35835     } catch (std::exception& e) {
35836       {
35837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35838       };
35839     } catch (Dali::DaliException e) {
35840       {
35841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35842       };
35843     } catch (...) {
35844       {
35845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35846       };
35847     }
35848   }
35849
35850   jresult = (int)result;
35851   return jresult;
35852 }
35853
35854
35855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35856   void * jresult ;
35857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35858   Dali::Vector4 result;
35859
35860   arg1 = (Dali::Actor *)jarg1;
35861   {
35862     try {
35863       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35864     } catch (std::out_of_range& e) {
35865       {
35866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35867       };
35868     } catch (std::exception& e) {
35869       {
35870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35871       };
35872     } catch (Dali::DaliException e) {
35873       {
35874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35875       };
35876     } catch (...) {
35877       {
35878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35879       };
35880     }
35881   }
35882
35883   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35884   return jresult;
35885 }
35886
35887
35888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35889   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35890   Dali::DrawMode::Type arg2 ;
35891
35892   arg1 = (Dali::Actor *)jarg1;
35893   arg2 = (Dali::DrawMode::Type)jarg2;
35894   {
35895     try {
35896       (arg1)->SetDrawMode(arg2);
35897     } catch (std::out_of_range& e) {
35898       {
35899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35900       };
35901     } catch (std::exception& e) {
35902       {
35903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35904       };
35905     } catch (Dali::DaliException e) {
35906       {
35907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35908       };
35909     } catch (...) {
35910       {
35911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35912       };
35913     }
35914   }
35915
35916 }
35917
35918
35919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35920   int jresult ;
35921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35922   Dali::DrawMode::Type result;
35923
35924   arg1 = (Dali::Actor *)jarg1;
35925   {
35926     try {
35927       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35928     } catch (std::out_of_range& e) {
35929       {
35930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35931       };
35932     } catch (std::exception& e) {
35933       {
35934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35935       };
35936     } catch (Dali::DaliException e) {
35937       {
35938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35939       };
35940     } catch (...) {
35941       {
35942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35943       };
35944     }
35945   }
35946
35947   jresult = (int)result;
35948   return jresult;
35949 }
35950
35951
35952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35953   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35954   bool arg2 ;
35955
35956   arg1 = (Dali::Actor *)jarg1;
35957   arg2 = jarg2 ? true : false;
35958   {
35959     try {
35960       (arg1)->SetSensitive(arg2);
35961     } catch (std::out_of_range& e) {
35962       {
35963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35964       };
35965     } catch (std::exception& e) {
35966       {
35967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35968       };
35969     } catch (Dali::DaliException e) {
35970       {
35971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35972       };
35973     } catch (...) {
35974       {
35975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35976       };
35977     }
35978   }
35979
35980 }
35981
35982
35983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35984   unsigned int jresult ;
35985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35986   bool result;
35987
35988   arg1 = (Dali::Actor *)jarg1;
35989   {
35990     try {
35991       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35992     } catch (std::out_of_range& e) {
35993       {
35994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35995       };
35996     } catch (std::exception& e) {
35997       {
35998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35999       };
36000     } catch (Dali::DaliException e) {
36001       {
36002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36003       };
36004     } catch (...) {
36005       {
36006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36007       };
36008     }
36009   }
36010
36011   jresult = result;
36012   return jresult;
36013 }
36014
36015
36016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36017   unsigned int jresult ;
36018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36019   float *arg2 = 0 ;
36020   float *arg3 = 0 ;
36021   float arg4 ;
36022   float arg5 ;
36023   bool result;
36024
36025   arg1 = (Dali::Actor *)jarg1;
36026   arg2 = (float *)jarg2;
36027   arg3 = (float *)jarg3;
36028   arg4 = (float)jarg4;
36029   arg5 = (float)jarg5;
36030   {
36031     try {
36032       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36033     } catch (std::out_of_range& e) {
36034       {
36035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36036       };
36037     } catch (std::exception& e) {
36038       {
36039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36040       };
36041     } catch (Dali::DaliException e) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36044       };
36045     } catch (...) {
36046       {
36047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36048       };
36049     }
36050   }
36051
36052   jresult = result;
36053   return jresult;
36054 }
36055
36056
36057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36059   bool arg2 ;
36060
36061   arg1 = (Dali::Actor *)jarg1;
36062   arg2 = jarg2 ? true : false;
36063   {
36064     try {
36065       (arg1)->SetLeaveRequired(arg2);
36066     } catch (std::out_of_range& e) {
36067       {
36068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36069       };
36070     } catch (std::exception& e) {
36071       {
36072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36073       };
36074     } catch (Dali::DaliException e) {
36075       {
36076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36077       };
36078     } catch (...) {
36079       {
36080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36081       };
36082     }
36083   }
36084
36085 }
36086
36087
36088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36089   unsigned int jresult ;
36090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36091   bool result;
36092
36093   arg1 = (Dali::Actor *)jarg1;
36094   {
36095     try {
36096       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36097     } catch (std::out_of_range& e) {
36098       {
36099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36100       };
36101     } catch (std::exception& e) {
36102       {
36103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36104       };
36105     } catch (Dali::DaliException e) {
36106       {
36107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36108       };
36109     } catch (...) {
36110       {
36111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36112       };
36113     }
36114   }
36115
36116   jresult = result;
36117   return jresult;
36118 }
36119
36120
36121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36122   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36123   bool arg2 ;
36124
36125   arg1 = (Dali::Actor *)jarg1;
36126   arg2 = jarg2 ? true : false;
36127   {
36128     try {
36129       (arg1)->SetKeyboardFocusable(arg2);
36130     } catch (std::out_of_range& e) {
36131       {
36132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36133       };
36134     } catch (std::exception& e) {
36135       {
36136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36137       };
36138     } catch (Dali::DaliException e) {
36139       {
36140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36141       };
36142     } catch (...) {
36143       {
36144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36145       };
36146     }
36147   }
36148
36149 }
36150
36151
36152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36153   unsigned int jresult ;
36154   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36155   bool result;
36156
36157   arg1 = (Dali::Actor *)jarg1;
36158   {
36159     try {
36160       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36161     } catch (std::out_of_range& e) {
36162       {
36163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36164       };
36165     } catch (std::exception& e) {
36166       {
36167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36168       };
36169     } catch (Dali::DaliException e) {
36170       {
36171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36172       };
36173     } catch (...) {
36174       {
36175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36176       };
36177     }
36178   }
36179
36180   jresult = result;
36181   return jresult;
36182 }
36183
36184
36185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36187   Dali::ResizePolicy::Type arg2 ;
36188   Dali::Dimension::Type arg3 ;
36189
36190   arg1 = (Dali::Actor *)jarg1;
36191   arg2 = (Dali::ResizePolicy::Type)jarg2;
36192   arg3 = (Dali::Dimension::Type)jarg3;
36193   {
36194     try {
36195       (arg1)->SetResizePolicy(arg2,arg3);
36196     } catch (std::out_of_range& e) {
36197       {
36198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36199       };
36200     } catch (std::exception& e) {
36201       {
36202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36203       };
36204     } catch (Dali::DaliException e) {
36205       {
36206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36207       };
36208     } catch (...) {
36209       {
36210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36211       };
36212     }
36213   }
36214
36215 }
36216
36217
36218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36219   int jresult ;
36220   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36221   Dali::Dimension::Type arg2 ;
36222   Dali::ResizePolicy::Type result;
36223
36224   arg1 = (Dali::Actor *)jarg1;
36225   arg2 = (Dali::Dimension::Type)jarg2;
36226   {
36227     try {
36228       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36229     } catch (std::out_of_range& e) {
36230       {
36231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36232       };
36233     } catch (std::exception& e) {
36234       {
36235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36236       };
36237     } catch (Dali::DaliException e) {
36238       {
36239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36240       };
36241     } catch (...) {
36242       {
36243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36244       };
36245     }
36246   }
36247
36248   jresult = (int)result;
36249   return jresult;
36250 }
36251
36252
36253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36255   Dali::SizeScalePolicy::Type arg2 ;
36256
36257   arg1 = (Dali::Actor *)jarg1;
36258   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36259   {
36260     try {
36261       (arg1)->SetSizeScalePolicy(arg2);
36262     } catch (std::out_of_range& e) {
36263       {
36264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36265       };
36266     } catch (std::exception& e) {
36267       {
36268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36269       };
36270     } catch (Dali::DaliException e) {
36271       {
36272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36273       };
36274     } catch (...) {
36275       {
36276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36277       };
36278     }
36279   }
36280
36281 }
36282
36283
36284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36285   int jresult ;
36286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36287   Dali::SizeScalePolicy::Type result;
36288
36289   arg1 = (Dali::Actor *)jarg1;
36290   {
36291     try {
36292       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36293     } catch (std::out_of_range& e) {
36294       {
36295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36296       };
36297     } catch (std::exception& e) {
36298       {
36299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36300       };
36301     } catch (Dali::DaliException e) {
36302       {
36303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36304       };
36305     } catch (...) {
36306       {
36307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36308       };
36309     }
36310   }
36311
36312   jresult = (int)result;
36313   return jresult;
36314 }
36315
36316
36317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36319   Dali::Vector3 *arg2 = 0 ;
36320
36321   arg1 = (Dali::Actor *)jarg1;
36322   arg2 = (Dali::Vector3 *)jarg2;
36323   if (!arg2) {
36324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36325     return ;
36326   }
36327   {
36328     try {
36329       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36330     } catch (std::out_of_range& e) {
36331       {
36332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36333       };
36334     } catch (std::exception& e) {
36335       {
36336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36337       };
36338     } catch (Dali::DaliException e) {
36339       {
36340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36341       };
36342     } catch (...) {
36343       {
36344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36345       };
36346     }
36347   }
36348
36349 }
36350
36351
36352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36353   void * jresult ;
36354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36355   Dali::Vector3 result;
36356
36357   arg1 = (Dali::Actor *)jarg1;
36358   {
36359     try {
36360       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36361     } catch (std::out_of_range& e) {
36362       {
36363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (std::exception& e) {
36366       {
36367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36368       };
36369     } catch (Dali::DaliException e) {
36370       {
36371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36372       };
36373     } catch (...) {
36374       {
36375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36376       };
36377     }
36378   }
36379
36380   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36381   return jresult;
36382 }
36383
36384
36385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36386   float jresult ;
36387   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36388   float arg2 ;
36389   float result;
36390
36391   arg1 = (Dali::Actor *)jarg1;
36392   arg2 = (float)jarg2;
36393   {
36394     try {
36395       result = (float)(arg1)->GetHeightForWidth(arg2);
36396     } catch (std::out_of_range& e) {
36397       {
36398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36399       };
36400     } catch (std::exception& e) {
36401       {
36402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36403       };
36404     } catch (Dali::DaliException e) {
36405       {
36406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36407       };
36408     } catch (...) {
36409       {
36410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36411       };
36412     }
36413   }
36414
36415   jresult = result;
36416   return jresult;
36417 }
36418
36419
36420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36421   float jresult ;
36422   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36423   float arg2 ;
36424   float result;
36425
36426   arg1 = (Dali::Actor *)jarg1;
36427   arg2 = (float)jarg2;
36428   {
36429     try {
36430       result = (float)(arg1)->GetWidthForHeight(arg2);
36431     } catch (std::out_of_range& e) {
36432       {
36433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36434       };
36435     } catch (std::exception& e) {
36436       {
36437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36438       };
36439     } catch (Dali::DaliException e) {
36440       {
36441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36442       };
36443     } catch (...) {
36444       {
36445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36446       };
36447     }
36448   }
36449
36450   jresult = result;
36451   return jresult;
36452 }
36453
36454
36455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36456   float jresult ;
36457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36458   Dali::Dimension::Type arg2 ;
36459   float result;
36460
36461   arg1 = (Dali::Actor *)jarg1;
36462   arg2 = (Dali::Dimension::Type)jarg2;
36463   {
36464     try {
36465       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36466     } catch (std::out_of_range& e) {
36467       {
36468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36469       };
36470     } catch (std::exception& e) {
36471       {
36472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36473       };
36474     } catch (Dali::DaliException e) {
36475       {
36476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36477       };
36478     } catch (...) {
36479       {
36480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36481       };
36482     }
36483   }
36484
36485   jresult = result;
36486   return jresult;
36487 }
36488
36489
36490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36492   Dali::Padding *arg2 = 0 ;
36493
36494   arg1 = (Dali::Actor *)jarg1;
36495   arg2 = (Dali::Padding *)jarg2;
36496   if (!arg2) {
36497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36498     return ;
36499   }
36500   {
36501     try {
36502       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36503     } catch (std::out_of_range& e) {
36504       {
36505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36506       };
36507     } catch (std::exception& e) {
36508       {
36509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36510       };
36511     } catch (Dali::DaliException e) {
36512       {
36513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36514       };
36515     } catch (...) {
36516       {
36517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36518       };
36519     }
36520   }
36521
36522 }
36523
36524
36525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36526   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36527   Dali::Padding *arg2 = 0 ;
36528
36529   arg1 = (Dali::Actor *)jarg1;
36530   arg2 = (Dali::Padding *)jarg2;
36531   if (!arg2) {
36532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36533     return ;
36534   }
36535   {
36536     try {
36537       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36538     } catch (std::out_of_range& e) {
36539       {
36540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36541       };
36542     } catch (std::exception& e) {
36543       {
36544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36545       };
36546     } catch (Dali::DaliException e) {
36547       {
36548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36549       };
36550     } catch (...) {
36551       {
36552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36553       };
36554     }
36555   }
36556
36557 }
36558
36559
36560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36562   Dali::Vector2 *arg2 = 0 ;
36563
36564   arg1 = (Dali::Actor *)jarg1;
36565   arg2 = (Dali::Vector2 *)jarg2;
36566   if (!arg2) {
36567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36568     return ;
36569   }
36570   {
36571     try {
36572       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36573     } catch (std::out_of_range& e) {
36574       {
36575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36576       };
36577     } catch (std::exception& e) {
36578       {
36579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36580       };
36581     } catch (Dali::DaliException e) {
36582       {
36583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36584       };
36585     } catch (...) {
36586       {
36587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36588       };
36589     }
36590   }
36591
36592 }
36593
36594
36595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36596   void * jresult ;
36597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36598   Dali::Vector2 result;
36599
36600   arg1 = (Dali::Actor *)jarg1;
36601   {
36602     try {
36603       result = (arg1)->GetMinimumSize();
36604     } catch (std::out_of_range& e) {
36605       {
36606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36607       };
36608     } catch (std::exception& e) {
36609       {
36610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36611       };
36612     } catch (Dali::DaliException e) {
36613       {
36614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36615       };
36616     } catch (...) {
36617       {
36618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36619       };
36620     }
36621   }
36622
36623   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36624   return jresult;
36625 }
36626
36627
36628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36629   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36630   Dali::Vector2 *arg2 = 0 ;
36631
36632   arg1 = (Dali::Actor *)jarg1;
36633   arg2 = (Dali::Vector2 *)jarg2;
36634   if (!arg2) {
36635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36636     return ;
36637   }
36638   {
36639     try {
36640       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36641     } catch (std::out_of_range& e) {
36642       {
36643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36644       };
36645     } catch (std::exception& e) {
36646       {
36647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36648       };
36649     } catch (Dali::DaliException e) {
36650       {
36651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36652       };
36653     } catch (...) {
36654       {
36655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36656       };
36657     }
36658   }
36659
36660 }
36661
36662
36663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36664   void * jresult ;
36665   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36666   Dali::Vector2 result;
36667
36668   arg1 = (Dali::Actor *)jarg1;
36669   {
36670     try {
36671       result = (arg1)->GetMaximumSize();
36672     } catch (std::out_of_range& e) {
36673       {
36674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36675       };
36676     } catch (std::exception& e) {
36677       {
36678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36679       };
36680     } catch (Dali::DaliException e) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36683       };
36684     } catch (...) {
36685       {
36686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36687       };
36688     }
36689   }
36690
36691   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36692   return jresult;
36693 }
36694
36695
36696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36697   int jresult ;
36698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36699   int result;
36700
36701   arg1 = (Dali::Actor *)jarg1;
36702   {
36703     try {
36704       result = (int)(arg1)->GetHierarchyDepth();
36705       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36706       if(parent)
36707       {
36708         const std::string parentName = parent.GetName();
36709         if(parentName.compare("rootAbsoluteLayout") == 0)
36710         {
36711           result -= 1;
36712         }
36713       }
36714     } catch (std::out_of_range& e) {
36715       {
36716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36717       };
36718     } catch (std::exception& e) {
36719       {
36720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36721       };
36722     } catch (Dali::DaliException e) {
36723       {
36724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36725       };
36726     } catch (...) {
36727       {
36728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36729       };
36730     }
36731   }
36732
36733   jresult = result;
36734   return jresult;
36735 }
36736
36737
36738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36739   unsigned int jresult ;
36740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36741   Dali::Renderer *arg2 = 0 ;
36742   unsigned int result;
36743
36744   arg1 = (Dali::Actor *)jarg1;
36745   arg2 = (Dali::Renderer *)jarg2;
36746   if (!arg2) {
36747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36748     return 0;
36749   }
36750   {
36751     try {
36752       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36753     } catch (std::out_of_range& e) {
36754       {
36755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36756       };
36757     } catch (std::exception& e) {
36758       {
36759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36760       };
36761     } catch (Dali::DaliException e) {
36762       {
36763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36764       };
36765     } catch (...) {
36766       {
36767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36768       };
36769     }
36770   }
36771
36772   jresult = result;
36773   return jresult;
36774 }
36775
36776
36777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36778   unsigned int jresult ;
36779   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36780   unsigned int result;
36781
36782   arg1 = (Dali::Actor *)jarg1;
36783   {
36784     try {
36785       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36786     } catch (std::out_of_range& e) {
36787       {
36788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36789       };
36790     } catch (std::exception& e) {
36791       {
36792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36793       };
36794     } catch (Dali::DaliException e) {
36795       {
36796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36797       };
36798     } catch (...) {
36799       {
36800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36801       };
36802     }
36803   }
36804
36805   jresult = result;
36806   return jresult;
36807 }
36808
36809
36810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36811   void * jresult ;
36812   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36813   unsigned int arg2 ;
36814   Dali::Renderer result;
36815
36816   arg1 = (Dali::Actor *)jarg1;
36817   arg2 = (unsigned int)jarg2;
36818   {
36819     try {
36820       result = (arg1)->GetRendererAt(arg2);
36821     } catch (std::out_of_range& e) {
36822       {
36823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36824       };
36825     } catch (std::exception& e) {
36826       {
36827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36828       };
36829     } catch (Dali::DaliException e) {
36830       {
36831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36832       };
36833     } catch (...) {
36834       {
36835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36836       };
36837     }
36838   }
36839
36840   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36841   return jresult;
36842 }
36843
36844
36845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36847   Dali::Renderer *arg2 = 0 ;
36848
36849   arg1 = (Dali::Actor *)jarg1;
36850   arg2 = (Dali::Renderer *)jarg2;
36851   if (!arg2) {
36852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36853     return ;
36854   }
36855   {
36856     try {
36857       (arg1)->RemoveRenderer(*arg2);
36858     } catch (std::out_of_range& e) {
36859       {
36860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36861       };
36862     } catch (std::exception& e) {
36863       {
36864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36865       };
36866     } catch (Dali::DaliException e) {
36867       {
36868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36869       };
36870     } catch (...) {
36871       {
36872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36873       };
36874     }
36875   }
36876
36877 }
36878
36879
36880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36882   unsigned int arg2 ;
36883
36884   arg1 = (Dali::Actor *)jarg1;
36885   arg2 = (unsigned int)jarg2;
36886   {
36887     try {
36888       (arg1)->RemoveRenderer(arg2);
36889     } catch (std::out_of_range& e) {
36890       {
36891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36892       };
36893     } catch (std::exception& e) {
36894       {
36895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36896       };
36897     } catch (Dali::DaliException e) {
36898       {
36899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36900       };
36901     } catch (...) {
36902       {
36903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36904       };
36905     }
36906   }
36907
36908 }
36909
36910
36911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36912   void * jresult ;
36913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36914   Dali::Actor::TouchSignalType *result = 0 ;
36915
36916   arg1 = (Dali::Actor *)jarg1;
36917   {
36918     try {
36919       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36920     } catch (std::out_of_range& e) {
36921       {
36922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36923       };
36924     } catch (std::exception& e) {
36925       {
36926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36927       };
36928     } catch (Dali::DaliException e) {
36929       {
36930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36931       };
36932     } catch (...) {
36933       {
36934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36935       };
36936     }
36937   }
36938
36939   jresult = (void *)result;
36940   return jresult;
36941 }
36942
36943
36944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36945   void * jresult ;
36946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36947   Dali::Actor::TouchDataSignalType *result = 0 ;
36948
36949   arg1 = (Dali::Actor *)jarg1;
36950   {
36951     try {
36952       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36953     } catch (std::out_of_range& e) {
36954       {
36955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36956       };
36957     } catch (std::exception& e) {
36958       {
36959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36960       };
36961     } catch (Dali::DaliException e) {
36962       {
36963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36964       };
36965     } catch (...) {
36966       {
36967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36968       };
36969     }
36970   }
36971
36972   jresult = (void *)result;
36973   return jresult;
36974 }
36975
36976
36977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36978   void * jresult ;
36979   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36980   Dali::Actor::HoverSignalType *result = 0 ;
36981
36982   arg1 = (Dali::Actor *)jarg1;
36983   {
36984     try {
36985       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36986     } catch (std::out_of_range& e) {
36987       {
36988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36989       };
36990     } catch (std::exception& e) {
36991       {
36992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36993       };
36994     } catch (Dali::DaliException e) {
36995       {
36996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36997       };
36998     } catch (...) {
36999       {
37000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37001       };
37002     }
37003   }
37004
37005   jresult = (void *)result;
37006   return jresult;
37007 }
37008
37009
37010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37011   void * jresult ;
37012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37013   Dali::Actor::WheelEventSignalType *result = 0 ;
37014
37015   arg1 = (Dali::Actor *)jarg1;
37016   {
37017     try {
37018       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37019     } catch (std::out_of_range& e) {
37020       {
37021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37022       };
37023     } catch (std::exception& e) {
37024       {
37025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37026       };
37027     } catch (Dali::DaliException e) {
37028       {
37029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37030       };
37031     } catch (...) {
37032       {
37033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37034       };
37035     }
37036   }
37037
37038   jresult = (void *)result;
37039   return jresult;
37040 }
37041
37042
37043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37044   void * jresult ;
37045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37046   Dali::Actor::OnStageSignalType *result = 0 ;
37047
37048   arg1 = (Dali::Actor *)jarg1;
37049   {
37050     try {
37051       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37052     } catch (std::out_of_range& e) {
37053       {
37054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37055       };
37056     } catch (std::exception& e) {
37057       {
37058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37059       };
37060     } catch (Dali::DaliException e) {
37061       {
37062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37063       };
37064     } catch (...) {
37065       {
37066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37067       };
37068     }
37069   }
37070
37071   jresult = (void *)result;
37072   return jresult;
37073 }
37074
37075
37076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37077   void * jresult ;
37078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37079   Dali::Actor::OffStageSignalType *result = 0 ;
37080
37081   arg1 = (Dali::Actor *)jarg1;
37082   {
37083     try {
37084       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37085     } catch (std::out_of_range& e) {
37086       {
37087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37088       };
37089     } catch (std::exception& e) {
37090       {
37091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37092       };
37093     } catch (Dali::DaliException e) {
37094       {
37095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37096       };
37097     } catch (...) {
37098       {
37099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37100       };
37101     }
37102   }
37103
37104   jresult = (void *)result;
37105   return jresult;
37106 }
37107
37108
37109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37110   void * jresult ;
37111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37112   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37113
37114   arg1 = (Dali::Actor *)jarg1;
37115   {
37116     try {
37117       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37118     } catch (std::out_of_range& e) {
37119       {
37120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37121       };
37122     } catch (std::exception& e) {
37123       {
37124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37125       };
37126     } catch (Dali::DaliException e) {
37127       {
37128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37129       };
37130     } catch (...) {
37131       {
37132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37133       };
37134     }
37135   }
37136
37137   jresult = (void *)result;
37138   return jresult;
37139 }
37140
37141
37142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37143   Dali::Actor *arg1 = 0 ;
37144
37145   arg1 = (Dali::Actor *)jarg1;
37146   if (!arg1) {
37147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37148     return ;
37149   }
37150   {
37151     try {
37152       Dali::UnparentAndReset(*arg1);
37153     } catch (std::out_of_range& e) {
37154       {
37155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37156       };
37157     } catch (std::exception& e) {
37158       {
37159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37160       };
37161     } catch (Dali::DaliException e) {
37162       {
37163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37164       };
37165     } catch (...) {
37166       {
37167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37168       };
37169     }
37170   }
37171
37172 }
37173
37174
37175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37176   int jresult ;
37177   int result;
37178
37179   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37180   jresult = (int)result;
37181   return jresult;
37182 }
37183
37184
37185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37186   int jresult ;
37187   int result;
37188
37189   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37190   jresult = (int)result;
37191   return jresult;
37192 }
37193
37194
37195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37196   int jresult ;
37197   int result;
37198
37199   result = (int)Dali::Layer::Property::BEHAVIOR;
37200   jresult = (int)result;
37201   return jresult;
37202 }
37203
37204
37205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37206   void * jresult ;
37207   Dali::Layer::Property *result = 0 ;
37208
37209   {
37210     try {
37211       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37212     } catch (std::out_of_range& e) {
37213       {
37214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37215       };
37216     } catch (std::exception& e) {
37217       {
37218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37219       };
37220     } catch (Dali::DaliException e) {
37221       {
37222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37223       };
37224     } catch (...) {
37225       {
37226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37227       };
37228     }
37229   }
37230
37231   jresult = (void *)result;
37232   return jresult;
37233 }
37234
37235
37236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37237   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37238
37239   arg1 = (Dali::Layer::Property *)jarg1;
37240   {
37241     try {
37242       delete arg1;
37243     } catch (std::out_of_range& e) {
37244       {
37245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37246       };
37247     } catch (std::exception& e) {
37248       {
37249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37250       };
37251     } catch (Dali::DaliException e) {
37252       {
37253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37254       };
37255     } catch (...) {
37256       {
37257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37258       };
37259     }
37260   }
37261
37262 }
37263
37264
37265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37266   void * jresult ;
37267   Dali::Layer *result = 0 ;
37268
37269   {
37270     try {
37271       result = (Dali::Layer *)new Dali::Layer();
37272     } catch (std::out_of_range& e) {
37273       {
37274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37275       };
37276     } catch (std::exception& e) {
37277       {
37278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37279       };
37280     } catch (Dali::DaliException e) {
37281       {
37282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37283       };
37284     } catch (...) {
37285       {
37286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37287       };
37288     }
37289   }
37290
37291   jresult = (void *)result;
37292   return jresult;
37293 }
37294
37295
37296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37297   void * jresult ;
37298   Dali::Layer result;
37299
37300   {
37301     try {
37302       result = Dali::Layer::New();
37303     } catch (std::out_of_range& e) {
37304       {
37305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37306       };
37307     } catch (std::exception& e) {
37308       {
37309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37310       };
37311     } catch (Dali::DaliException e) {
37312       {
37313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37314       };
37315     } catch (...) {
37316       {
37317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37318       };
37319     }
37320   }
37321
37322   jresult = new Dali::Layer((const Dali::Layer &)result);
37323   return jresult;
37324 }
37325
37326
37327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37328   void * jresult ;
37329   Dali::BaseHandle arg1 ;
37330   Dali::BaseHandle *argp1 ;
37331   Dali::Layer result;
37332
37333   argp1 = (Dali::BaseHandle *)jarg1;
37334   if (!argp1) {
37335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37336     return 0;
37337   }
37338   arg1 = *argp1;
37339   {
37340     try {
37341       result = Dali::Layer::DownCast(arg1);
37342     } catch (std::out_of_range& e) {
37343       {
37344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37345       };
37346     } catch (std::exception& e) {
37347       {
37348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37349       };
37350     } catch (Dali::DaliException e) {
37351       {
37352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37353       };
37354     } catch (...) {
37355       {
37356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37357       };
37358     }
37359   }
37360
37361   jresult = new Dali::Layer((const Dali::Layer &)result);
37362   return jresult;
37363 }
37364
37365
37366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37367   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37368
37369   arg1 = (Dali::Layer *)jarg1;
37370   {
37371     try {
37372       delete arg1;
37373     } catch (std::out_of_range& e) {
37374       {
37375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37376       };
37377     } catch (std::exception& e) {
37378       {
37379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37380       };
37381     } catch (Dali::DaliException e) {
37382       {
37383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37384       };
37385     } catch (...) {
37386       {
37387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37388       };
37389     }
37390   }
37391
37392 }
37393
37394
37395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37396   void * jresult ;
37397   Dali::Layer *arg1 = 0 ;
37398   Dali::Layer *result = 0 ;
37399
37400   arg1 = (Dali::Layer *)jarg1;
37401   if (!arg1) {
37402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37403     return 0;
37404   }
37405   {
37406     try {
37407       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37408     } catch (std::out_of_range& e) {
37409       {
37410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37411       };
37412     } catch (std::exception& e) {
37413       {
37414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37415       };
37416     } catch (Dali::DaliException e) {
37417       {
37418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37419       };
37420     } catch (...) {
37421       {
37422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37423       };
37424     }
37425   }
37426
37427   jresult = (void *)result;
37428   return jresult;
37429 }
37430
37431
37432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37433   void * jresult ;
37434   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37435   Dali::Layer *arg2 = 0 ;
37436   Dali::Layer *result = 0 ;
37437
37438   arg1 = (Dali::Layer *)jarg1;
37439   arg2 = (Dali::Layer *)jarg2;
37440   if (!arg2) {
37441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37442     return 0;
37443   }
37444   {
37445     try {
37446       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37447     } catch (std::out_of_range& e) {
37448       {
37449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37450       };
37451     } catch (std::exception& e) {
37452       {
37453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37454       };
37455     } catch (Dali::DaliException e) {
37456       {
37457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37458       };
37459     } catch (...) {
37460       {
37461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37462       };
37463     }
37464   }
37465
37466   jresult = (void *)result;
37467   return jresult;
37468 }
37469
37470
37471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37472   unsigned int jresult ;
37473   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37474   unsigned int result;
37475
37476   arg1 = (Dali::Layer *)jarg1;
37477   {
37478     try {
37479       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37480     } catch (std::out_of_range& e) {
37481       {
37482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37483       };
37484     } catch (std::exception& e) {
37485       {
37486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37487       };
37488     } catch (Dali::DaliException e) {
37489       {
37490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37491       };
37492     } catch (...) {
37493       {
37494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37495       };
37496     }
37497   }
37498
37499   jresult = result;
37500   return jresult;
37501 }
37502
37503
37504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37505   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37506
37507   arg1 = (Dali::Layer *)jarg1;
37508   {
37509     try {
37510       (arg1)->Raise();
37511     } catch (std::out_of_range& e) {
37512       {
37513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37514       };
37515     } catch (std::exception& e) {
37516       {
37517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37518       };
37519     } catch (Dali::DaliException e) {
37520       {
37521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37522       };
37523     } catch (...) {
37524       {
37525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37526       };
37527     }
37528   }
37529
37530 }
37531
37532
37533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37534   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37535
37536   arg1 = (Dali::Layer *)jarg1;
37537   {
37538     try {
37539       (arg1)->Lower();
37540     } catch (std::out_of_range& e) {
37541       {
37542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37543       };
37544     } catch (std::exception& e) {
37545       {
37546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37547       };
37548     } catch (Dali::DaliException e) {
37549       {
37550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37551       };
37552     } catch (...) {
37553       {
37554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37555       };
37556     }
37557   }
37558
37559 }
37560
37561
37562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37563   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37564   Dali::Layer arg2 ;
37565   Dali::Layer *argp2 ;
37566
37567   arg1 = (Dali::Layer *)jarg1;
37568   argp2 = (Dali::Layer *)jarg2;
37569   if (!argp2) {
37570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37571     return ;
37572   }
37573   arg2 = *argp2;
37574   {
37575     try {
37576       (arg1)->RaiseAbove(arg2);
37577     } catch (std::out_of_range& e) {
37578       {
37579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37580       };
37581     } catch (std::exception& e) {
37582       {
37583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37584       };
37585     } catch (Dali::DaliException e) {
37586       {
37587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37588       };
37589     } catch (...) {
37590       {
37591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37592       };
37593     }
37594   }
37595
37596 }
37597
37598
37599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37600   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37601   Dali::Layer arg2 ;
37602   Dali::Layer *argp2 ;
37603
37604   arg1 = (Dali::Layer *)jarg1;
37605   argp2 = (Dali::Layer *)jarg2;
37606   if (!argp2) {
37607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37608     return ;
37609   }
37610   arg2 = *argp2;
37611   {
37612     try {
37613       (arg1)->LowerBelow(arg2);
37614     } catch (std::out_of_range& e) {
37615       {
37616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37617       };
37618     } catch (std::exception& e) {
37619       {
37620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37621       };
37622     } catch (Dali::DaliException e) {
37623       {
37624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37625       };
37626     } catch (...) {
37627       {
37628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37629       };
37630     }
37631   }
37632
37633 }
37634
37635
37636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37637   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37638
37639   arg1 = (Dali::Layer *)jarg1;
37640   {
37641     try {
37642       (arg1)->RaiseToTop();
37643     } catch (std::out_of_range& e) {
37644       {
37645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37646       };
37647     } catch (std::exception& e) {
37648       {
37649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37650       };
37651     } catch (Dali::DaliException e) {
37652       {
37653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37654       };
37655     } catch (...) {
37656       {
37657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37658       };
37659     }
37660   }
37661
37662 }
37663
37664
37665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37666   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37667
37668   arg1 = (Dali::Layer *)jarg1;
37669   {
37670     try {
37671       (arg1)->LowerToBottom();
37672     } catch (std::out_of_range& e) {
37673       {
37674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37675       };
37676     } catch (std::exception& e) {
37677       {
37678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37679       };
37680     } catch (Dali::DaliException e) {
37681       {
37682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37683       };
37684     } catch (...) {
37685       {
37686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37687       };
37688     }
37689   }
37690
37691 }
37692
37693
37694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37695   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37696   Dali::Layer arg2 ;
37697   Dali::Layer *argp2 ;
37698
37699   arg1 = (Dali::Layer *)jarg1;
37700   argp2 = (Dali::Layer *)jarg2;
37701   if (!argp2) {
37702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37703     return ;
37704   }
37705   arg2 = *argp2;
37706   {
37707     try {
37708       (arg1)->MoveAbove(arg2);
37709     } catch (std::out_of_range& e) {
37710       {
37711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37712       };
37713     } catch (std::exception& e) {
37714       {
37715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37716       };
37717     } catch (Dali::DaliException e) {
37718       {
37719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37720       };
37721     } catch (...) {
37722       {
37723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37724       };
37725     }
37726   }
37727
37728 }
37729
37730
37731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37732   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37733   Dali::Layer arg2 ;
37734   Dali::Layer *argp2 ;
37735
37736   arg1 = (Dali::Layer *)jarg1;
37737   argp2 = (Dali::Layer *)jarg2;
37738   if (!argp2) {
37739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37740     return ;
37741   }
37742   arg2 = *argp2;
37743   {
37744     try {
37745       (arg1)->MoveBelow(arg2);
37746     } catch (std::out_of_range& e) {
37747       {
37748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37749       };
37750     } catch (std::exception& e) {
37751       {
37752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37753       };
37754     } catch (Dali::DaliException e) {
37755       {
37756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37757       };
37758     } catch (...) {
37759       {
37760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37761       };
37762     }
37763   }
37764
37765 }
37766
37767
37768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37769   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37770   Dali::Layer::Behavior arg2 ;
37771
37772   arg1 = (Dali::Layer *)jarg1;
37773   arg2 = (Dali::Layer::Behavior)jarg2;
37774   {
37775     try {
37776       (arg1)->SetBehavior(arg2);
37777     } catch (std::out_of_range& e) {
37778       {
37779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37780       };
37781     } catch (std::exception& e) {
37782       {
37783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37784       };
37785     } catch (Dali::DaliException e) {
37786       {
37787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37788       };
37789     } catch (...) {
37790       {
37791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37792       };
37793     }
37794   }
37795
37796 }
37797
37798
37799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37800   int jresult ;
37801   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37802   Dali::Layer::Behavior result;
37803
37804   arg1 = (Dali::Layer *)jarg1;
37805   {
37806     try {
37807       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37808     } catch (std::out_of_range& e) {
37809       {
37810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37811       };
37812     } catch (std::exception& e) {
37813       {
37814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37815       };
37816     } catch (Dali::DaliException e) {
37817       {
37818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37819       };
37820     } catch (...) {
37821       {
37822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37823       };
37824     }
37825   }
37826
37827   jresult = (int)result;
37828   return jresult;
37829 }
37830
37831
37832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37833   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37834   bool arg2 ;
37835
37836   arg1 = (Dali::Layer *)jarg1;
37837   arg2 = jarg2 ? true : false;
37838   {
37839     try {
37840       (arg1)->SetClipping(arg2);
37841     } catch (std::out_of_range& e) {
37842       {
37843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37844       };
37845     } catch (std::exception& e) {
37846       {
37847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37848       };
37849     } catch (Dali::DaliException e) {
37850       {
37851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37852       };
37853     } catch (...) {
37854       {
37855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37856       };
37857     }
37858   }
37859
37860 }
37861
37862
37863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37864   unsigned int jresult ;
37865   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37866   bool result;
37867
37868   arg1 = (Dali::Layer *)jarg1;
37869   {
37870     try {
37871       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37872     } catch (std::out_of_range& e) {
37873       {
37874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37875       };
37876     } catch (std::exception& e) {
37877       {
37878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37879       };
37880     } catch (Dali::DaliException e) {
37881       {
37882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37883       };
37884     } catch (...) {
37885       {
37886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37887       };
37888     }
37889   }
37890
37891   jresult = result;
37892   return jresult;
37893 }
37894
37895
37896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37897   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37898   int arg2 ;
37899   int arg3 ;
37900   int arg4 ;
37901   int arg5 ;
37902
37903   arg1 = (Dali::Layer *)jarg1;
37904   arg2 = (int)jarg2;
37905   arg3 = (int)jarg3;
37906   arg4 = (int)jarg4;
37907   arg5 = (int)jarg5;
37908   {
37909     try {
37910       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37911     } catch (std::out_of_range& e) {
37912       {
37913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37914       };
37915     } catch (std::exception& e) {
37916       {
37917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37918       };
37919     } catch (Dali::DaliException e) {
37920       {
37921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37922       };
37923     } catch (...) {
37924       {
37925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37926       };
37927     }
37928   }
37929
37930 }
37931
37932
37933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37934   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37935   Dali::ClippingBox arg2 ;
37936   Dali::ClippingBox *argp2 ;
37937
37938   arg1 = (Dali::Layer *)jarg1;
37939   argp2 = (Dali::ClippingBox *)jarg2;
37940   if (!argp2) {
37941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37942     return ;
37943   }
37944   arg2 = *argp2;
37945   {
37946     try {
37947       (arg1)->SetClippingBox(arg2);
37948     } catch (std::out_of_range& e) {
37949       {
37950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37951       };
37952     } catch (std::exception& e) {
37953       {
37954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37955       };
37956     } catch (Dali::DaliException e) {
37957       {
37958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37959       };
37960     } catch (...) {
37961       {
37962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37963       };
37964     }
37965   }
37966
37967 }
37968
37969
37970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37971   void * jresult ;
37972   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37973   Dali::ClippingBox result;
37974
37975   arg1 = (Dali::Layer *)jarg1;
37976   {
37977     try {
37978       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37979     } catch (std::out_of_range& e) {
37980       {
37981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37982       };
37983     } catch (std::exception& e) {
37984       {
37985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37986       };
37987     } catch (Dali::DaliException e) {
37988       {
37989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37990       };
37991     } catch (...) {
37992       {
37993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37994       };
37995     }
37996   }
37997
37998   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37999   return jresult;
38000 }
38001
38002
38003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38004   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38005   bool arg2 ;
38006
38007   arg1 = (Dali::Layer *)jarg1;
38008   arg2 = jarg2 ? true : false;
38009   {
38010     try {
38011       (arg1)->SetDepthTestDisabled(arg2);
38012     } catch (std::out_of_range& e) {
38013       {
38014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38015       };
38016     } catch (std::exception& e) {
38017       {
38018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38019       };
38020     } catch (Dali::DaliException e) {
38021       {
38022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38023       };
38024     } catch (...) {
38025       {
38026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38027       };
38028     }
38029   }
38030
38031 }
38032
38033
38034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38035   unsigned int jresult ;
38036   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38037   bool result;
38038
38039   arg1 = (Dali::Layer *)jarg1;
38040   {
38041     try {
38042       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38043     } catch (std::out_of_range& e) {
38044       {
38045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38046       };
38047     } catch (std::exception& e) {
38048       {
38049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38050       };
38051     } catch (Dali::DaliException e) {
38052       {
38053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38054       };
38055     } catch (...) {
38056       {
38057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38058       };
38059     }
38060   }
38061
38062   jresult = result;
38063   return jresult;
38064 }
38065
38066
38067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38068   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38069   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38070
38071   arg1 = (Dali::Layer *)jarg1;
38072   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38073   {
38074     try {
38075       (arg1)->SetSortFunction(arg2);
38076     } catch (std::out_of_range& e) {
38077       {
38078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38079       };
38080     } catch (std::exception& e) {
38081       {
38082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38083       };
38084     } catch (Dali::DaliException e) {
38085       {
38086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38087       };
38088     } catch (...) {
38089       {
38090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38091       };
38092     }
38093   }
38094
38095 }
38096
38097
38098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38099   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38100   bool arg2 ;
38101
38102   arg1 = (Dali::Layer *)jarg1;
38103   arg2 = jarg2 ? true : false;
38104   {
38105     try {
38106       (arg1)->SetTouchConsumed(arg2);
38107     } catch (std::out_of_range& e) {
38108       {
38109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38110       };
38111     } catch (std::exception& e) {
38112       {
38113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38114       };
38115     } catch (Dali::DaliException e) {
38116       {
38117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38118       };
38119     } catch (...) {
38120       {
38121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38122       };
38123     }
38124   }
38125
38126 }
38127
38128
38129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38130   unsigned int jresult ;
38131   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38132   bool result;
38133
38134   arg1 = (Dali::Layer *)jarg1;
38135   {
38136     try {
38137       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38138     } catch (std::out_of_range& e) {
38139       {
38140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38141       };
38142     } catch (std::exception& e) {
38143       {
38144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38145       };
38146     } catch (Dali::DaliException e) {
38147       {
38148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38149       };
38150     } catch (...) {
38151       {
38152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38153       };
38154     }
38155   }
38156
38157   jresult = result;
38158   return jresult;
38159 }
38160
38161
38162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38163   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38164   bool arg2 ;
38165
38166   arg1 = (Dali::Layer *)jarg1;
38167   arg2 = jarg2 ? true : false;
38168   {
38169     try {
38170       (arg1)->SetHoverConsumed(arg2);
38171     } catch (std::out_of_range& e) {
38172       {
38173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38174       };
38175     } catch (std::exception& e) {
38176       {
38177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38178       };
38179     } catch (Dali::DaliException e) {
38180       {
38181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38182       };
38183     } catch (...) {
38184       {
38185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38186       };
38187     }
38188   }
38189
38190 }
38191
38192
38193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38194   unsigned int jresult ;
38195   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38196   bool result;
38197
38198   arg1 = (Dali::Layer *)jarg1;
38199   {
38200     try {
38201       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38202     } catch (std::out_of_range& e) {
38203       {
38204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38205       };
38206     } catch (std::exception& e) {
38207       {
38208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38209       };
38210     } catch (Dali::DaliException e) {
38211       {
38212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38213       };
38214     } catch (...) {
38215       {
38216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38217       };
38218     }
38219   }
38220
38221   jresult = result;
38222   return jresult;
38223 }
38224
38225
38226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38227   void * jresult ;
38228   Dali::Vector4 *result = 0 ;
38229
38230   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38231   jresult = (void *)result;
38232   return jresult;
38233 }
38234
38235
38236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38237   void * jresult ;
38238   Dali::Vector4 *result = 0 ;
38239
38240   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38241   jresult = (void *)result;
38242   return jresult;
38243 }
38244
38245
38246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38247   void * jresult ;
38248   Dali::Stage *result = 0 ;
38249
38250   {
38251     try {
38252       result = (Dali::Stage *)new Dali::Stage();
38253     } catch (std::out_of_range& e) {
38254       {
38255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38256       };
38257     } catch (std::exception& e) {
38258       {
38259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38260       };
38261     } catch (Dali::DaliException e) {
38262       {
38263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38264       };
38265     } catch (...) {
38266       {
38267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38268       };
38269     }
38270   }
38271
38272   jresult = (void *)result;
38273   return jresult;
38274 }
38275
38276
38277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38278   void * jresult ;
38279   Dali::Stage result;
38280
38281   {
38282     try {
38283       result = Dali::Stage::GetCurrent();
38284     } catch (std::out_of_range& e) {
38285       {
38286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38287       };
38288     } catch (std::exception& e) {
38289       {
38290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38291       };
38292     } catch (Dali::DaliException e) {
38293       {
38294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38295       };
38296     } catch (...) {
38297       {
38298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38299       };
38300     }
38301   }
38302
38303   jresult = new Dali::Stage((const Dali::Stage &)result);
38304   return jresult;
38305 }
38306
38307
38308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38309   unsigned int jresult ;
38310   bool result;
38311
38312   {
38313     try {
38314       result = (bool)Dali::Stage::IsInstalled();
38315     } catch (std::out_of_range& e) {
38316       {
38317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38318       };
38319     } catch (std::exception& e) {
38320       {
38321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38322       };
38323     } catch (Dali::DaliException e) {
38324       {
38325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38326       };
38327     } catch (...) {
38328       {
38329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38330       };
38331     }
38332   }
38333
38334   jresult = result;
38335   return jresult;
38336 }
38337
38338
38339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38340   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38341
38342   arg1 = (Dali::Stage *)jarg1;
38343   {
38344     try {
38345       delete arg1;
38346     } catch (std::out_of_range& e) {
38347       {
38348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38349       };
38350     } catch (std::exception& e) {
38351       {
38352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38353       };
38354     } catch (Dali::DaliException e) {
38355       {
38356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38357       };
38358     } catch (...) {
38359       {
38360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38361       };
38362     }
38363   }
38364
38365 }
38366
38367
38368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38369   void * jresult ;
38370   Dali::Stage *arg1 = 0 ;
38371   Dali::Stage *result = 0 ;
38372
38373   arg1 = (Dali::Stage *)jarg1;
38374   if (!arg1) {
38375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38376     return 0;
38377   }
38378   {
38379     try {
38380       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38381     } catch (std::out_of_range& e) {
38382       {
38383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38384       };
38385     } catch (std::exception& e) {
38386       {
38387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38388       };
38389     } catch (Dali::DaliException e) {
38390       {
38391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38392       };
38393     } catch (...) {
38394       {
38395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38396       };
38397     }
38398   }
38399
38400   jresult = (void *)result;
38401   return jresult;
38402 }
38403
38404
38405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38406   void * jresult ;
38407   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38408   Dali::Stage *arg2 = 0 ;
38409   Dali::Stage *result = 0 ;
38410
38411   arg1 = (Dali::Stage *)jarg1;
38412   arg2 = (Dali::Stage *)jarg2;
38413   if (!arg2) {
38414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38415     return 0;
38416   }
38417   {
38418     try {
38419       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38420     } catch (std::out_of_range& e) {
38421       {
38422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38423       };
38424     } catch (std::exception& e) {
38425       {
38426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38427       };
38428     } catch (Dali::DaliException e) {
38429       {
38430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38431       };
38432     } catch (...) {
38433       {
38434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38435       };
38436     }
38437   }
38438
38439   jresult = (void *)result;
38440   return jresult;
38441 }
38442
38443
38444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38445   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38446   Dali::Actor *arg2 = 0 ;
38447
38448   arg1 = (Dali::Stage *)jarg1;
38449   arg2 = (Dali::Actor *)jarg2;
38450   if (!arg2) {
38451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38452     return ;
38453   }
38454   {
38455     try {
38456       (arg1)->Add(*arg2);
38457     } catch (std::out_of_range& e) {
38458       {
38459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38460       };
38461     } catch (std::exception& e) {
38462       {
38463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38464       };
38465     } catch (Dali::DaliException e) {
38466       {
38467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38468       };
38469     } catch (...) {
38470       {
38471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38472       };
38473     }
38474   }
38475
38476 }
38477
38478
38479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38480   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38481   Dali::Actor *arg2 = 0 ;
38482
38483   arg1 = (Dali::Stage *)jarg1;
38484   arg2 = (Dali::Actor *)jarg2;
38485   if (!arg2) {
38486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38487     return ;
38488   }
38489   {
38490     try {
38491       (arg1)->Remove(*arg2);
38492     } catch (std::out_of_range& e) {
38493       {
38494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38495       };
38496     } catch (std::exception& e) {
38497       {
38498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38499       };
38500     } catch (Dali::DaliException e) {
38501       {
38502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38503       };
38504     } catch (...) {
38505       {
38506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38507       };
38508     }
38509   }
38510
38511 }
38512
38513
38514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38515   void * jresult ;
38516   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38517   Dali::Vector2 result;
38518
38519   arg1 = (Dali::Stage *)jarg1;
38520   {
38521     try {
38522       result = ((Dali::Stage const *)arg1)->GetSize();
38523     } catch (std::out_of_range& e) {
38524       {
38525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38526       };
38527     } catch (std::exception& e) {
38528       {
38529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38530       };
38531     } catch (Dali::DaliException e) {
38532       {
38533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38534       };
38535     } catch (...) {
38536       {
38537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38538       };
38539     }
38540   }
38541
38542   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38543   return jresult;
38544 }
38545
38546
38547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38548   void * jresult ;
38549   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38550   Dali::RenderTaskList result;
38551
38552   arg1 = (Dali::Stage *)jarg1;
38553   {
38554     try {
38555       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38556     } catch (std::out_of_range& e) {
38557       {
38558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38559       };
38560     } catch (std::exception& e) {
38561       {
38562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38563       };
38564     } catch (Dali::DaliException e) {
38565       {
38566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38567       };
38568     } catch (...) {
38569       {
38570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38571       };
38572     }
38573   }
38574
38575   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38576   return jresult;
38577 }
38578
38579
38580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38581   unsigned int jresult ;
38582   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38583   unsigned int result;
38584
38585   arg1 = (Dali::Stage *)jarg1;
38586   {
38587     try {
38588       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38589     } catch (std::out_of_range& e) {
38590       {
38591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38592       };
38593     } catch (std::exception& e) {
38594       {
38595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38596       };
38597     } catch (Dali::DaliException e) {
38598       {
38599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38600       };
38601     } catch (...) {
38602       {
38603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38604       };
38605     }
38606   }
38607
38608   jresult = result;
38609   return jresult;
38610 }
38611
38612
38613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38614   void * jresult ;
38615   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38616   unsigned int arg2 ;
38617   Dali::Layer result;
38618
38619   arg1 = (Dali::Stage *)jarg1;
38620   arg2 = (unsigned int)jarg2;
38621   {
38622     try {
38623       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38624     } catch (std::out_of_range& e) {
38625       {
38626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38627       };
38628     } catch (std::exception& e) {
38629       {
38630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38631       };
38632     } catch (Dali::DaliException e) {
38633       {
38634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38635       };
38636     } catch (...) {
38637       {
38638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38639       };
38640     }
38641   }
38642
38643   jresult = new Dali::Layer((const Dali::Layer &)result);
38644   return jresult;
38645 }
38646
38647
38648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38649   void * jresult ;
38650   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38651   Dali::Layer result;
38652
38653   arg1 = (Dali::Stage *)jarg1;
38654   {
38655     try {
38656       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38657     } catch (std::out_of_range& e) {
38658       {
38659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38660       };
38661     } catch (std::exception& e) {
38662       {
38663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38664       };
38665     } catch (Dali::DaliException e) {
38666       {
38667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38668       };
38669     } catch (...) {
38670       {
38671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38672       };
38673     }
38674   }
38675
38676   jresult = new Dali::Layer((const Dali::Layer &)result);
38677   return jresult;
38678 }
38679
38680
38681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38682   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38683   Dali::Vector4 arg2 ;
38684   Dali::Vector4 *argp2 ;
38685
38686   arg1 = (Dali::Stage *)jarg1;
38687   argp2 = (Dali::Vector4 *)jarg2;
38688   if (!argp2) {
38689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38690     return ;
38691   }
38692   arg2 = *argp2;
38693   {
38694     try {
38695       (arg1)->SetBackgroundColor(arg2);
38696     } catch (std::out_of_range& e) {
38697       {
38698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38699       };
38700     } catch (std::exception& e) {
38701       {
38702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38703       };
38704     } catch (Dali::DaliException e) {
38705       {
38706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38707       };
38708     } catch (...) {
38709       {
38710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38711       };
38712     }
38713   }
38714
38715 }
38716
38717
38718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38719   void * jresult ;
38720   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38721   Dali::Vector4 result;
38722
38723   arg1 = (Dali::Stage *)jarg1;
38724   {
38725     try {
38726       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38727     } catch (std::out_of_range& e) {
38728       {
38729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38730       };
38731     } catch (std::exception& e) {
38732       {
38733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38734       };
38735     } catch (Dali::DaliException e) {
38736       {
38737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38738       };
38739     } catch (...) {
38740       {
38741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38742       };
38743     }
38744   }
38745
38746   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38747   return jresult;
38748 }
38749
38750
38751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38752   void * jresult ;
38753   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38754   Dali::Vector2 result;
38755
38756   arg1 = (Dali::Stage *)jarg1;
38757   {
38758     try {
38759       result = ((Dali::Stage const *)arg1)->GetDpi();
38760     } catch (std::out_of_range& e) {
38761       {
38762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38763       };
38764     } catch (std::exception& e) {
38765       {
38766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38767       };
38768     } catch (Dali::DaliException e) {
38769       {
38770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38771       };
38772     } catch (...) {
38773       {
38774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38775       };
38776     }
38777   }
38778
38779   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38780   return jresult;
38781 }
38782
38783
38784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38785   void * jresult ;
38786   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38787   Dali::ObjectRegistry result;
38788
38789   arg1 = (Dali::Stage *)jarg1;
38790   {
38791     try {
38792       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38793     } catch (std::out_of_range& e) {
38794       {
38795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38796       };
38797     } catch (std::exception& e) {
38798       {
38799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38800       };
38801     } catch (Dali::DaliException e) {
38802       {
38803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38804       };
38805     } catch (...) {
38806       {
38807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38808       };
38809     }
38810   }
38811
38812   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38813   return jresult;
38814 }
38815
38816
38817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38818   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38819   float arg2 ;
38820
38821   arg1 = (Dali::Stage *)jarg1;
38822   arg2 = (float)jarg2;
38823   {
38824     try {
38825       (arg1)->KeepRendering(arg2);
38826     } catch (std::out_of_range& e) {
38827       {
38828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38829       };
38830     } catch (std::exception& e) {
38831       {
38832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38833       };
38834     } catch (Dali::DaliException e) {
38835       {
38836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38837       };
38838     } catch (...) {
38839       {
38840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38841       };
38842     }
38843   }
38844
38845 }
38846
38847
38848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38849   void * jresult ;
38850   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38851   Dali::Stage::KeyEventSignalType *result = 0 ;
38852
38853   arg1 = (Dali::Stage *)jarg1;
38854   {
38855     try {
38856       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38857     } catch (std::out_of_range& e) {
38858       {
38859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38860       };
38861     } catch (std::exception& e) {
38862       {
38863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38864       };
38865     } catch (Dali::DaliException e) {
38866       {
38867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38868       };
38869     } catch (...) {
38870       {
38871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38872       };
38873     }
38874   }
38875
38876   jresult = (void *)result;
38877   return jresult;
38878 }
38879
38880
38881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38882   void * jresult ;
38883   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38884   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38885
38886   arg1 = (Dali::Stage *)jarg1;
38887   {
38888     try {
38889       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38890     } catch (std::out_of_range& e) {
38891       {
38892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38893       };
38894     } catch (std::exception& e) {
38895       {
38896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38897       };
38898     } catch (Dali::DaliException e) {
38899       {
38900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38901       };
38902     } catch (...) {
38903       {
38904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38905       };
38906     }
38907   }
38908
38909   jresult = (void *)result;
38910   return jresult;
38911 }
38912
38913
38914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38915   void * jresult ;
38916   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38917   Dali::Stage::TouchSignalType *result = 0 ;
38918
38919   arg1 = (Dali::Stage *)jarg1;
38920   {
38921     try {
38922       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38923     } catch (std::out_of_range& e) {
38924       {
38925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38926       };
38927     } catch (std::exception& e) {
38928       {
38929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38930       };
38931     } catch (Dali::DaliException e) {
38932       {
38933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38934       };
38935     } catch (...) {
38936       {
38937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38938       };
38939     }
38940   }
38941
38942   jresult = (void *)result;
38943   return jresult;
38944 }
38945
38946
38947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38948   void * jresult ;
38949   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38950   Dali::Stage::WheelEventSignalType *result = 0 ;
38951
38952   arg1 = (Dali::Stage *)jarg1;
38953   {
38954     try {
38955       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38956     } catch (std::out_of_range& e) {
38957       {
38958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38959       };
38960     } catch (std::exception& e) {
38961       {
38962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38963       };
38964     } catch (Dali::DaliException e) {
38965       {
38966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38967       };
38968     } catch (...) {
38969       {
38970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38971       };
38972     }
38973   }
38974
38975   jresult = (void *)result;
38976   return jresult;
38977 }
38978
38979
38980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38981   void * jresult ;
38982   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38983   Dali::Stage::ContextStatusSignal *result = 0 ;
38984
38985   arg1 = (Dali::Stage *)jarg1;
38986   {
38987     try {
38988       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38989     } catch (std::out_of_range& e) {
38990       {
38991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38992       };
38993     } catch (std::exception& e) {
38994       {
38995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38996       };
38997     } catch (Dali::DaliException e) {
38998       {
38999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39000       };
39001     } catch (...) {
39002       {
39003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39004       };
39005     }
39006   }
39007
39008   jresult = (void *)result;
39009   return jresult;
39010 }
39011
39012
39013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39014   void * jresult ;
39015   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39016   Dali::Stage::ContextStatusSignal *result = 0 ;
39017
39018   arg1 = (Dali::Stage *)jarg1;
39019   {
39020     try {
39021       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39022     } catch (std::out_of_range& e) {
39023       {
39024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39025       };
39026     } catch (std::exception& e) {
39027       {
39028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39029       };
39030     } catch (Dali::DaliException e) {
39031       {
39032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39033       };
39034     } catch (...) {
39035       {
39036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39037       };
39038     }
39039   }
39040
39041   jresult = (void *)result;
39042   return jresult;
39043 }
39044
39045
39046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39047   void * jresult ;
39048   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39049   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39050
39051   arg1 = (Dali::Stage *)jarg1;
39052   {
39053     try {
39054       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39055     } catch (std::out_of_range& e) {
39056       {
39057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39058       };
39059     } catch (std::exception& e) {
39060       {
39061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39062       };
39063     } catch (Dali::DaliException e) {
39064       {
39065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39066       };
39067     } catch (...) {
39068       {
39069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39070       };
39071     }
39072   }
39073
39074   jresult = (void *)result;
39075   return jresult;
39076 }
39077
39078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39079   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39080   Dali::DevelStage::Rendering arg2 ;
39081
39082   arg1 = (Dali::Stage *)jarg1;
39083   arg2 = (Dali::DevelStage::Rendering)jarg2;
39084   {
39085     try {
39086       DevelStage::SetRenderingBehavior(*arg1,arg2);
39087     } catch (std::out_of_range& e) {
39088       {
39089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39090       };
39091     } catch (std::exception& e) {
39092       {
39093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39094       };
39095     } catch (Dali::DaliException e) {
39096       {
39097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39098       };
39099     } catch (...) {
39100       {
39101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39102       };
39103     }
39104   }
39105
39106 }
39107
39108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39109
39110   int jresult ;
39111   int result ;
39112   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39113
39114   arg1 = (Dali::Stage *)jarg1;
39115   {
39116     try {
39117       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39118     } catch (std::out_of_range& e) {
39119       {
39120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39121       };
39122     } catch (std::exception& e) {
39123       {
39124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39125       };
39126     } catch (Dali::DaliException e) {
39127       {
39128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39129       };
39130     } catch (...) {
39131       {
39132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39133       };
39134     }
39135   }
39136
39137   jresult = result;
39138   return jresult;
39139 }
39140
39141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39142   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39143
39144   arg1 = (Dali::RelayoutContainer *)jarg1;
39145   {
39146     try {
39147       delete arg1;
39148     } catch (std::out_of_range& e) {
39149       {
39150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39151       };
39152     } catch (std::exception& e) {
39153       {
39154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39155       };
39156     } catch (Dali::DaliException e) {
39157       {
39158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39159       };
39160     } catch (...) {
39161       {
39162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39163       };
39164     }
39165   }
39166
39167 }
39168
39169
39170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39171   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39172   Dali::Actor *arg2 = 0 ;
39173   Dali::Vector2 *arg3 = 0 ;
39174
39175   arg1 = (Dali::RelayoutContainer *)jarg1;
39176   arg2 = (Dali::Actor *)jarg2;
39177   if (!arg2) {
39178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39179     return ;
39180   }
39181   arg3 = (Dali::Vector2 *)jarg3;
39182   if (!arg3) {
39183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39184     return ;
39185   }
39186   {
39187     try {
39188       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39189     } catch (std::out_of_range& e) {
39190       {
39191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39192       };
39193     } catch (std::exception& e) {
39194       {
39195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39196       };
39197     } catch (Dali::DaliException e) {
39198       {
39199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39200       };
39201     } catch (...) {
39202       {
39203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39204       };
39205     }
39206   }
39207
39208 }
39209
39210
39211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39212   void * jresult ;
39213   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39214   Dali::CustomActor result;
39215
39216   arg1 = (Dali::CustomActorImpl *)jarg1;
39217   {
39218     try {
39219       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39220     } catch (std::out_of_range& e) {
39221       {
39222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39223       };
39224     } catch (std::exception& e) {
39225       {
39226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39227       };
39228     } catch (Dali::DaliException e) {
39229       {
39230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39231       };
39232     } catch (...) {
39233       {
39234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39235       };
39236     }
39237   }
39238
39239   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39240   return jresult;
39241 }
39242
39243
39244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39245   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39246   int arg2 ;
39247
39248   arg1 = (Dali::CustomActorImpl *)jarg1;
39249   arg2 = (int)jarg2;
39250   {
39251     try {
39252       (arg1)->OnStageConnection(arg2);
39253     } catch (std::out_of_range& e) {
39254       {
39255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39256       };
39257     } catch (std::exception& e) {
39258       {
39259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39260       };
39261     } catch (Dali::DaliException e) {
39262       {
39263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39264       };
39265     } catch (...) {
39266       {
39267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39268       };
39269     }
39270   }
39271
39272 }
39273
39274
39275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39276   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39277
39278   arg1 = (Dali::CustomActorImpl *)jarg1;
39279   {
39280     try {
39281       (arg1)->OnStageDisconnection();
39282     } catch (std::out_of_range& e) {
39283       {
39284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39285       };
39286     } catch (std::exception& e) {
39287       {
39288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39289       };
39290     } catch (Dali::DaliException e) {
39291       {
39292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39293       };
39294     } catch (...) {
39295       {
39296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39297       };
39298     }
39299   }
39300
39301 }
39302
39303
39304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39305   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39306   Dali::Actor *arg2 = 0 ;
39307
39308   arg1 = (Dali::CustomActorImpl *)jarg1;
39309   arg2 = (Dali::Actor *)jarg2;
39310   if (!arg2) {
39311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39312     return ;
39313   }
39314   {
39315     try {
39316       (arg1)->OnChildAdd(*arg2);
39317     } catch (std::out_of_range& e) {
39318       {
39319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39320       };
39321     } catch (std::exception& e) {
39322       {
39323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39324       };
39325     } catch (Dali::DaliException e) {
39326       {
39327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39328       };
39329     } catch (...) {
39330       {
39331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39332       };
39333     }
39334   }
39335
39336 }
39337
39338
39339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39340   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39341   Dali::Actor *arg2 = 0 ;
39342
39343   arg1 = (Dali::CustomActorImpl *)jarg1;
39344   arg2 = (Dali::Actor *)jarg2;
39345   if (!arg2) {
39346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39347     return ;
39348   }
39349   {
39350     try {
39351       (arg1)->OnChildRemove(*arg2);
39352     } catch (std::out_of_range& e) {
39353       {
39354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39355       };
39356     } catch (std::exception& e) {
39357       {
39358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39359       };
39360     } catch (Dali::DaliException e) {
39361       {
39362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39363       };
39364     } catch (...) {
39365       {
39366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39367       };
39368     }
39369   }
39370
39371 }
39372
39373
39374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39375   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39376   Dali::Property::Index arg2 ;
39377   Dali::Property::Value arg3 ;
39378   Dali::Property::Value *argp3 ;
39379
39380   arg1 = (Dali::CustomActorImpl *)jarg1;
39381   arg2 = (Dali::Property::Index)jarg2;
39382   argp3 = (Dali::Property::Value *)jarg3;
39383   if (!argp3) {
39384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39385     return ;
39386   }
39387   arg3 = *argp3;
39388   {
39389     try {
39390       (arg1)->OnPropertySet(arg2,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 void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39414   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39415   Dali::Vector3 *arg2 = 0 ;
39416
39417   arg1 = (Dali::CustomActorImpl *)jarg1;
39418   arg2 = (Dali::Vector3 *)jarg2;
39419   if (!arg2) {
39420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39421     return ;
39422   }
39423   {
39424     try {
39425       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39426     } catch (std::out_of_range& e) {
39427       {
39428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39429       };
39430     } catch (std::exception& e) {
39431       {
39432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39433       };
39434     } catch (Dali::DaliException e) {
39435       {
39436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39437       };
39438     } catch (...) {
39439       {
39440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39441       };
39442     }
39443   }
39444
39445 }
39446
39447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39448   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39449   Dali::Animation *arg2 = 0 ;
39450   Dali::Vector3 *arg3 = 0 ;
39451
39452   arg1 = (Dali::CustomActorImpl *)jarg1;
39453   arg2 = (Dali::Animation *)jarg2;
39454   if (!arg2) {
39455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39456     return ;
39457   }
39458   arg3 = (Dali::Vector3 *)jarg3;
39459   if (!arg3) {
39460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39461     return ;
39462   }
39463   {
39464     try {
39465       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39466     } catch (std::out_of_range& e) {
39467       {
39468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39469       };
39470     } catch (std::exception& e) {
39471       {
39472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39473       };
39474     } catch (Dali::DaliException e) {
39475       {
39476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39477       };
39478     } catch (...) {
39479       {
39480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39481       };
39482     }
39483   }
39484
39485 }
39486
39487
39488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39489   unsigned int jresult ;
39490   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39491   Dali::TouchEvent *arg2 = 0 ;
39492   bool result;
39493
39494   arg1 = (Dali::CustomActorImpl *)jarg1;
39495   arg2 = (Dali::TouchEvent *)jarg2;
39496   if (!arg2) {
39497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39498     return 0;
39499   }
39500   {
39501     try {
39502       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39503     } catch (std::out_of_range& e) {
39504       {
39505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39506       };
39507     } catch (std::exception& e) {
39508       {
39509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39510       };
39511     } catch (Dali::DaliException e) {
39512       {
39513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39514       };
39515     } catch (...) {
39516       {
39517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39518       };
39519     }
39520   }
39521
39522   jresult = result;
39523   return jresult;
39524 }
39525
39526
39527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39528   unsigned int jresult ;
39529   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39530   Dali::HoverEvent *arg2 = 0 ;
39531   bool result;
39532
39533   arg1 = (Dali::CustomActorImpl *)jarg1;
39534   arg2 = (Dali::HoverEvent *)jarg2;
39535   if (!arg2) {
39536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39537     return 0;
39538   }
39539   {
39540     try {
39541       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39542     } catch (std::out_of_range& e) {
39543       {
39544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39545       };
39546     } catch (std::exception& e) {
39547       {
39548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39549       };
39550     } catch (Dali::DaliException e) {
39551       {
39552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39553       };
39554     } catch (...) {
39555       {
39556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39557       };
39558     }
39559   }
39560
39561   jresult = result;
39562   return jresult;
39563 }
39564
39565
39566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39567   unsigned int jresult ;
39568   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39569   Dali::KeyEvent *arg2 = 0 ;
39570   bool result;
39571
39572   arg1 = (Dali::CustomActorImpl *)jarg1;
39573   arg2 = (Dali::KeyEvent *)jarg2;
39574   if (!arg2) {
39575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39576     return 0;
39577   }
39578   {
39579     try {
39580       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39581     } catch (std::out_of_range& e) {
39582       {
39583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39584       };
39585     } catch (std::exception& e) {
39586       {
39587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39588       };
39589     } catch (Dali::DaliException e) {
39590       {
39591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39592       };
39593     } catch (...) {
39594       {
39595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39596       };
39597     }
39598   }
39599
39600   jresult = result;
39601   return jresult;
39602 }
39603
39604
39605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39606   unsigned int jresult ;
39607   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39608   Dali::WheelEvent *arg2 = 0 ;
39609   bool result;
39610
39611   arg1 = (Dali::CustomActorImpl *)jarg1;
39612   arg2 = (Dali::WheelEvent *)jarg2;
39613   if (!arg2) {
39614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39615     return 0;
39616   }
39617   {
39618     try {
39619       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39620     } catch (std::out_of_range& e) {
39621       {
39622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39623       };
39624     } catch (std::exception& e) {
39625       {
39626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39627       };
39628     } catch (Dali::DaliException e) {
39629       {
39630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39631       };
39632     } catch (...) {
39633       {
39634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39635       };
39636     }
39637   }
39638
39639   jresult = result;
39640   return jresult;
39641 }
39642
39643
39644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39645   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39646   Dali::Vector2 *arg2 = 0 ;
39647   Dali::RelayoutContainer *arg3 = 0 ;
39648
39649   arg1 = (Dali::CustomActorImpl *)jarg1;
39650   arg2 = (Dali::Vector2 *)jarg2;
39651   if (!arg2) {
39652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39653     return ;
39654   }
39655   arg3 = (Dali::RelayoutContainer *)jarg3;
39656   if (!arg3) {
39657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39658     return ;
39659   }
39660   {
39661     try {
39662       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39663     } catch (std::out_of_range& e) {
39664       {
39665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39666       };
39667     } catch (std::exception& e) {
39668       {
39669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39670       };
39671     } catch (Dali::DaliException e) {
39672       {
39673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39674       };
39675     } catch (...) {
39676       {
39677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39678       };
39679     }
39680   }
39681
39682 }
39683
39684
39685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39686   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39687   Dali::ResizePolicy::Type arg2 ;
39688   Dali::Dimension::Type arg3 ;
39689
39690   arg1 = (Dali::CustomActorImpl *)jarg1;
39691   arg2 = (Dali::ResizePolicy::Type)jarg2;
39692   arg3 = (Dali::Dimension::Type)jarg3;
39693   {
39694     try {
39695       (arg1)->OnSetResizePolicy(arg2,arg3);
39696     } catch (std::out_of_range& e) {
39697       {
39698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39699       };
39700     } catch (std::exception& e) {
39701       {
39702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39703       };
39704     } catch (Dali::DaliException e) {
39705       {
39706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39707       };
39708     } catch (...) {
39709       {
39710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39711       };
39712     }
39713   }
39714
39715 }
39716
39717
39718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39719   void * jresult ;
39720   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39721   Dali::Vector3 result;
39722
39723   arg1 = (Dali::CustomActorImpl *)jarg1;
39724   {
39725     try {
39726       result = (arg1)->GetNaturalSize();
39727     } catch (std::out_of_range& e) {
39728       {
39729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39730       };
39731     } catch (std::exception& e) {
39732       {
39733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39734       };
39735     } catch (Dali::DaliException e) {
39736       {
39737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39738       };
39739     } catch (...) {
39740       {
39741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39742       };
39743     }
39744   }
39745
39746   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39747   return jresult;
39748 }
39749
39750
39751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39752   float jresult ;
39753   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39754   Dali::Actor *arg2 = 0 ;
39755   Dali::Dimension::Type arg3 ;
39756   float result;
39757
39758   arg1 = (Dali::CustomActorImpl *)jarg1;
39759   arg2 = (Dali::Actor *)jarg2;
39760   if (!arg2) {
39761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39762     return 0;
39763   }
39764   arg3 = (Dali::Dimension::Type)jarg3;
39765   {
39766     try {
39767       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39768     } catch (std::out_of_range& e) {
39769       {
39770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39771       };
39772     } catch (std::exception& e) {
39773       {
39774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39775       };
39776     } catch (Dali::DaliException e) {
39777       {
39778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39779       };
39780     } catch (...) {
39781       {
39782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39783       };
39784     }
39785   }
39786
39787   jresult = result;
39788   return jresult;
39789 }
39790
39791
39792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39793   float jresult ;
39794   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39795   float arg2 ;
39796   float result;
39797
39798   arg1 = (Dali::CustomActorImpl *)jarg1;
39799   arg2 = (float)jarg2;
39800   {
39801     try {
39802       result = (float)(arg1)->GetHeightForWidth(arg2);
39803     } catch (std::out_of_range& e) {
39804       {
39805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39806       };
39807     } catch (std::exception& e) {
39808       {
39809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39810       };
39811     } catch (Dali::DaliException e) {
39812       {
39813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39814       };
39815     } catch (...) {
39816       {
39817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39818       };
39819     }
39820   }
39821
39822   jresult = result;
39823   return jresult;
39824 }
39825
39826
39827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39828   float jresult ;
39829   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39830   float arg2 ;
39831   float result;
39832
39833   arg1 = (Dali::CustomActorImpl *)jarg1;
39834   arg2 = (float)jarg2;
39835   {
39836     try {
39837       result = (float)(arg1)->GetWidthForHeight(arg2);
39838     } catch (std::out_of_range& e) {
39839       {
39840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39841       };
39842     } catch (std::exception& e) {
39843       {
39844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39845       };
39846     } catch (Dali::DaliException e) {
39847       {
39848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39849       };
39850     } catch (...) {
39851       {
39852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39853       };
39854     }
39855   }
39856
39857   jresult = result;
39858   return jresult;
39859 }
39860
39861
39862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39863   unsigned int jresult ;
39864   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39865   Dali::Dimension::Type arg2 ;
39866   bool result;
39867
39868   arg1 = (Dali::CustomActorImpl *)jarg1;
39869   arg2 = (Dali::Dimension::Type)jarg2;
39870   {
39871     try {
39872       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39873     } catch (std::out_of_range& e) {
39874       {
39875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39876       };
39877     } catch (std::exception& e) {
39878       {
39879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39880       };
39881     } catch (Dali::DaliException e) {
39882       {
39883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39884       };
39885     } catch (...) {
39886       {
39887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39888       };
39889     }
39890   }
39891
39892   jresult = result;
39893   return jresult;
39894 }
39895
39896
39897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39898   unsigned int jresult ;
39899   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39900   bool result;
39901
39902   arg1 = (Dali::CustomActorImpl *)jarg1;
39903   {
39904     try {
39905       result = (bool)(arg1)->RelayoutDependentOnChildren();
39906     } catch (std::out_of_range& e) {
39907       {
39908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39909       };
39910     } catch (std::exception& e) {
39911       {
39912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39913       };
39914     } catch (Dali::DaliException e) {
39915       {
39916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39917       };
39918     } catch (...) {
39919       {
39920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39921       };
39922     }
39923   }
39924
39925   jresult = result;
39926   return jresult;
39927 }
39928
39929
39930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39931   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39932   Dali::Dimension::Type arg2 ;
39933
39934   arg1 = (Dali::CustomActorImpl *)jarg1;
39935   arg2 = (Dali::Dimension::Type)jarg2;
39936   {
39937     try {
39938       (arg1)->OnCalculateRelayoutSize(arg2);
39939     } catch (std::out_of_range& e) {
39940       {
39941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39942       };
39943     } catch (std::exception& e) {
39944       {
39945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39946       };
39947     } catch (Dali::DaliException e) {
39948       {
39949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39950       };
39951     } catch (...) {
39952       {
39953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39954       };
39955     }
39956   }
39957
39958 }
39959
39960
39961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39962   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39963   float arg2 ;
39964   Dali::Dimension::Type arg3 ;
39965
39966   arg1 = (Dali::CustomActorImpl *)jarg1;
39967   arg2 = (float)jarg2;
39968   arg3 = (Dali::Dimension::Type)jarg3;
39969   {
39970     try {
39971       (arg1)->OnLayoutNegotiated(arg2,arg3);
39972     } catch (std::out_of_range& e) {
39973       {
39974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39975       };
39976     } catch (std::exception& e) {
39977       {
39978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39979       };
39980     } catch (Dali::DaliException e) {
39981       {
39982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39983       };
39984     } catch (...) {
39985       {
39986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39987       };
39988     }
39989   }
39990
39991 }
39992
39993
39994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39995   unsigned int jresult ;
39996   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39997   bool result;
39998
39999   arg1 = (Dali::CustomActorImpl *)jarg1;
40000   {
40001     try {
40002       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40003     } catch (std::out_of_range& e) {
40004       {
40005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40006       };
40007     } catch (std::exception& e) {
40008       {
40009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40010       };
40011     } catch (Dali::DaliException e) {
40012       {
40013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40014       };
40015     } catch (...) {
40016       {
40017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40018       };
40019     }
40020   }
40021
40022   jresult = result;
40023   return jresult;
40024 }
40025
40026
40027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40028   unsigned int jresult ;
40029   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40030   bool result;
40031
40032   arg1 = (Dali::CustomActorImpl *)jarg1;
40033   {
40034     try {
40035       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40036     } catch (std::out_of_range& e) {
40037       {
40038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40039       };
40040     } catch (std::exception& e) {
40041       {
40042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40043       };
40044     } catch (Dali::DaliException e) {
40045       {
40046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40047       };
40048     } catch (...) {
40049       {
40050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40051       };
40052     }
40053   }
40054
40055   jresult = result;
40056   return jresult;
40057 }
40058
40059
40060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40061   unsigned int jresult ;
40062   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40063   bool result;
40064
40065   arg1 = (Dali::CustomActorImpl *)jarg1;
40066   {
40067     try {
40068       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40069     } catch (std::out_of_range& e) {
40070       {
40071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40072       };
40073     } catch (std::exception& e) {
40074       {
40075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40076       };
40077     } catch (Dali::DaliException e) {
40078       {
40079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40080       };
40081     } catch (...) {
40082       {
40083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40084       };
40085     }
40086   }
40087
40088   jresult = result;
40089   return jresult;
40090 }
40091
40092
40093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40094   unsigned int jresult ;
40095   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40096   bool result;
40097
40098   arg1 = (Dali::CustomActorImpl *)jarg1;
40099   {
40100     try {
40101       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40102     } catch (std::out_of_range& e) {
40103       {
40104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40105       };
40106     } catch (std::exception& e) {
40107       {
40108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40109       };
40110     } catch (Dali::DaliException e) {
40111       {
40112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40113       };
40114     } catch (...) {
40115       {
40116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40117       };
40118     }
40119   }
40120
40121   jresult = result;
40122   return jresult;
40123 }
40124
40125
40126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40127   void * jresult ;
40128   Dali::CustomActor *result = 0 ;
40129
40130   {
40131     try {
40132       result = (Dali::CustomActor *)new Dali::CustomActor();
40133     } catch (std::out_of_range& e) {
40134       {
40135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40136       };
40137     } catch (std::exception& e) {
40138       {
40139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40140       };
40141     } catch (Dali::DaliException e) {
40142       {
40143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40144       };
40145     } catch (...) {
40146       {
40147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40148       };
40149     }
40150   }
40151
40152   jresult = (void *)result;
40153   return jresult;
40154 }
40155
40156
40157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40158   void * jresult ;
40159   Dali::BaseHandle arg1 ;
40160   Dali::BaseHandle *argp1 ;
40161   Dali::CustomActor result;
40162
40163   argp1 = (Dali::BaseHandle *)jarg1;
40164   if (!argp1) {
40165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40166     return 0;
40167   }
40168   arg1 = *argp1;
40169   {
40170     try {
40171       result = Dali::CustomActor::DownCast(arg1);
40172     } catch (std::out_of_range& e) {
40173       {
40174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40175       };
40176     } catch (std::exception& e) {
40177       {
40178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40179       };
40180     } catch (Dali::DaliException e) {
40181       {
40182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40183       };
40184     } catch (...) {
40185       {
40186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40187       };
40188     }
40189   }
40190
40191   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40192   return jresult;
40193 }
40194
40195
40196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40197   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40198
40199   arg1 = (Dali::CustomActor *)jarg1;
40200   {
40201     try {
40202       delete arg1;
40203     } catch (std::out_of_range& e) {
40204       {
40205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40206       };
40207     } catch (std::exception& e) {
40208       {
40209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40210       };
40211     } catch (Dali::DaliException e) {
40212       {
40213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40214       };
40215     } catch (...) {
40216       {
40217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40218       };
40219     }
40220   }
40221
40222 }
40223
40224
40225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40226   void * jresult ;
40227   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40228   Dali::CustomActorImpl *result = 0 ;
40229
40230   arg1 = (Dali::CustomActor *)jarg1;
40231   {
40232     try {
40233       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40234     } catch (std::out_of_range& e) {
40235       {
40236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40237       };
40238     } catch (std::exception& e) {
40239       {
40240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40241       };
40242     } catch (Dali::DaliException e) {
40243       {
40244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40245       };
40246     } catch (...) {
40247       {
40248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40249       };
40250     }
40251   }
40252
40253   jresult = (void *)result;
40254   return jresult;
40255 }
40256
40257
40258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40259   void * jresult ;
40260   Dali::CustomActorImpl *arg1 = 0 ;
40261   Dali::CustomActor *result = 0 ;
40262
40263   arg1 = (Dali::CustomActorImpl *)jarg1;
40264   if (!arg1) {
40265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40266     return 0;
40267   }
40268   {
40269     try {
40270       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40271     } catch (std::out_of_range& e) {
40272       {
40273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40274       };
40275     } catch (std::exception& e) {
40276       {
40277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40278       };
40279     } catch (Dali::DaliException e) {
40280       {
40281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40282       };
40283     } catch (...) {
40284       {
40285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40286       };
40287     }
40288   }
40289
40290   jresult = (void *)result;
40291   return jresult;
40292 }
40293
40294
40295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40296   void * jresult ;
40297   Dali::CustomActor *arg1 = 0 ;
40298   Dali::CustomActor *result = 0 ;
40299
40300   arg1 = (Dali::CustomActor *)jarg1;
40301   if (!arg1) {
40302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40303     return 0;
40304   }
40305   {
40306     try {
40307       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40308     } catch (std::out_of_range& e) {
40309       {
40310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40311       };
40312     } catch (std::exception& e) {
40313       {
40314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40315       };
40316     } catch (Dali::DaliException e) {
40317       {
40318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40319       };
40320     } catch (...) {
40321       {
40322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40323       };
40324     }
40325   }
40326
40327   jresult = (void *)result;
40328   return jresult;
40329 }
40330
40331
40332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40333   void * jresult ;
40334   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40335   Dali::CustomActor *arg2 = 0 ;
40336   Dali::CustomActor *result = 0 ;
40337
40338   arg1 = (Dali::CustomActor *)jarg1;
40339   arg2 = (Dali::CustomActor *)jarg2;
40340   if (!arg2) {
40341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40342     return 0;
40343   }
40344   {
40345     try {
40346       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40347     } catch (std::out_of_range& e) {
40348       {
40349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40350       };
40351     } catch (std::exception& e) {
40352       {
40353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40354       };
40355     } catch (Dali::DaliException e) {
40356       {
40357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40358       };
40359     } catch (...) {
40360       {
40361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40362       };
40363     }
40364   }
40365
40366   jresult = (void *)result;
40367   return jresult;
40368 }
40369
40370
40371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40372   int jresult ;
40373   int result;
40374
40375   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40376   jresult = (int)result;
40377   return jresult;
40378 }
40379
40380
40381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40382   int jresult ;
40383   int result;
40384
40385   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40386   jresult = (int)result;
40387   return jresult;
40388 }
40389
40390
40391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40392   int jresult ;
40393   int result;
40394
40395   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40396   jresult = (int)result;
40397   return jresult;
40398 }
40399
40400
40401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40402   int jresult ;
40403   int result;
40404
40405   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40406   jresult = (int)result;
40407   return jresult;
40408 }
40409
40410
40411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40412   int jresult ;
40413   int result;
40414
40415   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40416   jresult = (int)result;
40417   return jresult;
40418 }
40419
40420
40421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40422   int jresult ;
40423   int result;
40424
40425   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40426   jresult = (int)result;
40427   return jresult;
40428 }
40429
40430
40431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40432   int jresult ;
40433   int result;
40434
40435   result = (int)Dali::PanGestureDetector::Property::PANNING;
40436   jresult = (int)result;
40437   return jresult;
40438 }
40439
40440
40441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40442   void * jresult ;
40443   Dali::PanGestureDetector::Property *result = 0 ;
40444
40445   {
40446     try {
40447       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40448     } catch (std::out_of_range& e) {
40449       {
40450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40451       };
40452     } catch (std::exception& e) {
40453       {
40454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40455       };
40456     } catch (Dali::DaliException e) {
40457       {
40458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40459       };
40460     } catch (...) {
40461       {
40462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40463       };
40464     }
40465   }
40466
40467   jresult = (void *)result;
40468   return jresult;
40469 }
40470
40471
40472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40473   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40474
40475   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40476   {
40477     try {
40478       delete arg1;
40479     } catch (std::out_of_range& e) {
40480       {
40481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40482       };
40483     } catch (std::exception& e) {
40484       {
40485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40486       };
40487     } catch (Dali::DaliException e) {
40488       {
40489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40490       };
40491     } catch (...) {
40492       {
40493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40494       };
40495     }
40496   }
40497
40498 }
40499
40500
40501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40502   void * jresult ;
40503   Dali::Radian *result = 0 ;
40504
40505   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40506   jresult = (void *)result;
40507   return jresult;
40508 }
40509
40510
40511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40512   void * jresult ;
40513   Dali::Radian *result = 0 ;
40514
40515   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40516   jresult = (void *)result;
40517   return jresult;
40518 }
40519
40520
40521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40522   void * jresult ;
40523   Dali::Radian *result = 0 ;
40524
40525   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40526   jresult = (void *)result;
40527   return jresult;
40528 }
40529
40530
40531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40532   void * jresult ;
40533   Dali::Radian *result = 0 ;
40534
40535   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40536   jresult = (void *)result;
40537   return jresult;
40538 }
40539
40540
40541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40542   void * jresult ;
40543   Dali::Radian *result = 0 ;
40544
40545   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40546   jresult = (void *)result;
40547   return jresult;
40548 }
40549
40550
40551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40552   void * jresult ;
40553   Dali::Radian *result = 0 ;
40554
40555   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40556   jresult = (void *)result;
40557   return jresult;
40558 }
40559
40560
40561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40562   void * jresult ;
40563   Dali::Radian *result = 0 ;
40564
40565   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40566   jresult = (void *)result;
40567   return jresult;
40568 }
40569
40570
40571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40572   void * jresult ;
40573   Dali::PanGestureDetector *result = 0 ;
40574
40575   {
40576     try {
40577       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40578     } catch (std::out_of_range& e) {
40579       {
40580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40581       };
40582     } catch (std::exception& e) {
40583       {
40584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40585       };
40586     } catch (Dali::DaliException e) {
40587       {
40588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40589       };
40590     } catch (...) {
40591       {
40592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40593       };
40594     }
40595   }
40596
40597   jresult = (void *)result;
40598   return jresult;
40599 }
40600
40601
40602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40603   void * jresult ;
40604   Dali::PanGestureDetector result;
40605
40606   {
40607     try {
40608       result = Dali::PanGestureDetector::New();
40609     } catch (std::out_of_range& e) {
40610       {
40611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40612       };
40613     } catch (std::exception& e) {
40614       {
40615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40616       };
40617     } catch (Dali::DaliException e) {
40618       {
40619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40620       };
40621     } catch (...) {
40622       {
40623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40624       };
40625     }
40626   }
40627
40628   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40629   return jresult;
40630 }
40631
40632
40633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40634   void * jresult ;
40635   Dali::BaseHandle arg1 ;
40636   Dali::BaseHandle *argp1 ;
40637   Dali::PanGestureDetector result;
40638
40639   argp1 = (Dali::BaseHandle *)jarg1;
40640   if (!argp1) {
40641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40642     return 0;
40643   }
40644   arg1 = *argp1;
40645   {
40646     try {
40647       result = Dali::PanGestureDetector::DownCast(arg1);
40648     } catch (std::out_of_range& e) {
40649       {
40650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40651       };
40652     } catch (std::exception& e) {
40653       {
40654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40655       };
40656     } catch (Dali::DaliException e) {
40657       {
40658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40659       };
40660     } catch (...) {
40661       {
40662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40663       };
40664     }
40665   }
40666
40667   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40668   return jresult;
40669 }
40670
40671
40672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40673   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40674
40675   arg1 = (Dali::PanGestureDetector *)jarg1;
40676   {
40677     try {
40678       delete arg1;
40679     } catch (std::out_of_range& e) {
40680       {
40681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40682       };
40683     } catch (std::exception& e) {
40684       {
40685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40686       };
40687     } catch (Dali::DaliException e) {
40688       {
40689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40690       };
40691     } catch (...) {
40692       {
40693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40694       };
40695     }
40696   }
40697
40698 }
40699
40700
40701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40702   void * jresult ;
40703   Dali::PanGestureDetector *arg1 = 0 ;
40704   Dali::PanGestureDetector *result = 0 ;
40705
40706   arg1 = (Dali::PanGestureDetector *)jarg1;
40707   if (!arg1) {
40708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40709     return 0;
40710   }
40711   {
40712     try {
40713       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40714     } catch (std::out_of_range& e) {
40715       {
40716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40717       };
40718     } catch (std::exception& e) {
40719       {
40720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40721       };
40722     } catch (Dali::DaliException e) {
40723       {
40724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40725       };
40726     } catch (...) {
40727       {
40728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40729       };
40730     }
40731   }
40732
40733   jresult = (void *)result;
40734   return jresult;
40735 }
40736
40737
40738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40739   void * jresult ;
40740   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40741   Dali::PanGestureDetector *arg2 = 0 ;
40742   Dali::PanGestureDetector *result = 0 ;
40743
40744   arg1 = (Dali::PanGestureDetector *)jarg1;
40745   arg2 = (Dali::PanGestureDetector *)jarg2;
40746   if (!arg2) {
40747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40748     return 0;
40749   }
40750   {
40751     try {
40752       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40753     } catch (std::out_of_range& e) {
40754       {
40755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40756       };
40757     } catch (std::exception& e) {
40758       {
40759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40760       };
40761     } catch (Dali::DaliException e) {
40762       {
40763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40764       };
40765     } catch (...) {
40766       {
40767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40768       };
40769     }
40770   }
40771
40772   jresult = (void *)result;
40773   return jresult;
40774 }
40775
40776
40777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40778   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40779   unsigned int arg2 ;
40780
40781   arg1 = (Dali::PanGestureDetector *)jarg1;
40782   arg2 = (unsigned int)jarg2;
40783   {
40784     try {
40785       (arg1)->SetMinimumTouchesRequired(arg2);
40786     } catch (std::out_of_range& e) {
40787       {
40788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40789       };
40790     } catch (std::exception& e) {
40791       {
40792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40793       };
40794     } catch (Dali::DaliException e) {
40795       {
40796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40797       };
40798     } catch (...) {
40799       {
40800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40801       };
40802     }
40803   }
40804
40805 }
40806
40807
40808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40809   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40810   unsigned int arg2 ;
40811
40812   arg1 = (Dali::PanGestureDetector *)jarg1;
40813   arg2 = (unsigned int)jarg2;
40814   {
40815     try {
40816       (arg1)->SetMaximumTouchesRequired(arg2);
40817     } catch (std::out_of_range& e) {
40818       {
40819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40820       };
40821     } catch (std::exception& e) {
40822       {
40823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40824       };
40825     } catch (Dali::DaliException e) {
40826       {
40827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40828       };
40829     } catch (...) {
40830       {
40831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40832       };
40833     }
40834   }
40835
40836 }
40837
40838
40839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40840   unsigned int jresult ;
40841   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40842   unsigned int result;
40843
40844   arg1 = (Dali::PanGestureDetector *)jarg1;
40845   {
40846     try {
40847       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40848     } catch (std::out_of_range& e) {
40849       {
40850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40851       };
40852     } catch (std::exception& e) {
40853       {
40854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40855       };
40856     } catch (Dali::DaliException e) {
40857       {
40858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40859       };
40860     } catch (...) {
40861       {
40862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40863       };
40864     }
40865   }
40866
40867   jresult = result;
40868   return jresult;
40869 }
40870
40871
40872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40873   unsigned int jresult ;
40874   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40875   unsigned int result;
40876
40877   arg1 = (Dali::PanGestureDetector *)jarg1;
40878   {
40879     try {
40880       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40881     } catch (std::out_of_range& e) {
40882       {
40883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40884       };
40885     } catch (std::exception& e) {
40886       {
40887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40888       };
40889     } catch (Dali::DaliException e) {
40890       {
40891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40892       };
40893     } catch (...) {
40894       {
40895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40896       };
40897     }
40898   }
40899
40900   jresult = result;
40901   return jresult;
40902 }
40903
40904
40905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40906   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40907   Dali::Radian arg2 ;
40908   Dali::Radian arg3 ;
40909   Dali::Radian *argp2 ;
40910   Dali::Radian *argp3 ;
40911
40912   arg1 = (Dali::PanGestureDetector *)jarg1;
40913   argp2 = (Dali::Radian *)jarg2;
40914   if (!argp2) {
40915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40916     return ;
40917   }
40918   arg2 = *argp2;
40919   argp3 = (Dali::Radian *)jarg3;
40920   if (!argp3) {
40921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40922     return ;
40923   }
40924   arg3 = *argp3;
40925   {
40926     try {
40927       (arg1)->AddAngle(arg2,arg3);
40928     } catch (std::out_of_range& e) {
40929       {
40930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40931       };
40932     } catch (std::exception& e) {
40933       {
40934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40935       };
40936     } catch (Dali::DaliException e) {
40937       {
40938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40939       };
40940     } catch (...) {
40941       {
40942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40943       };
40944     }
40945   }
40946
40947 }
40948
40949
40950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40951   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40952   Dali::Radian arg2 ;
40953   Dali::Radian *argp2 ;
40954
40955   arg1 = (Dali::PanGestureDetector *)jarg1;
40956   argp2 = (Dali::Radian *)jarg2;
40957   if (!argp2) {
40958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40959     return ;
40960   }
40961   arg2 = *argp2;
40962   {
40963     try {
40964       (arg1)->AddAngle(arg2);
40965     } catch (std::out_of_range& e) {
40966       {
40967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40968       };
40969     } catch (std::exception& e) {
40970       {
40971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40972       };
40973     } catch (Dali::DaliException e) {
40974       {
40975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40976       };
40977     } catch (...) {
40978       {
40979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40980       };
40981     }
40982   }
40983
40984 }
40985
40986
40987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40988   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40989   Dali::Radian arg2 ;
40990   Dali::Radian arg3 ;
40991   Dali::Radian *argp2 ;
40992   Dali::Radian *argp3 ;
40993
40994   arg1 = (Dali::PanGestureDetector *)jarg1;
40995   argp2 = (Dali::Radian *)jarg2;
40996   if (!argp2) {
40997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40998     return ;
40999   }
41000   arg2 = *argp2;
41001   argp3 = (Dali::Radian *)jarg3;
41002   if (!argp3) {
41003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41004     return ;
41005   }
41006   arg3 = *argp3;
41007   {
41008     try {
41009       (arg1)->AddDirection(arg2,arg3);
41010     } catch (std::out_of_range& e) {
41011       {
41012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41013       };
41014     } catch (std::exception& e) {
41015       {
41016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41017       };
41018     } catch (Dali::DaliException e) {
41019       {
41020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41021       };
41022     } catch (...) {
41023       {
41024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41025       };
41026     }
41027   }
41028
41029 }
41030
41031
41032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41033   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41034   Dali::Radian arg2 ;
41035   Dali::Radian *argp2 ;
41036
41037   arg1 = (Dali::PanGestureDetector *)jarg1;
41038   argp2 = (Dali::Radian *)jarg2;
41039   if (!argp2) {
41040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41041     return ;
41042   }
41043   arg2 = *argp2;
41044   {
41045     try {
41046       (arg1)->AddDirection(arg2);
41047     } catch (std::out_of_range& e) {
41048       {
41049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41050       };
41051     } catch (std::exception& e) {
41052       {
41053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41054       };
41055     } catch (Dali::DaliException e) {
41056       {
41057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41058       };
41059     } catch (...) {
41060       {
41061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41062       };
41063     }
41064   }
41065
41066 }
41067
41068
41069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41070   unsigned long jresult ;
41071   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41072   size_t result;
41073
41074   arg1 = (Dali::PanGestureDetector *)jarg1;
41075   {
41076     try {
41077       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41078     } catch (std::out_of_range& e) {
41079       {
41080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41081       };
41082     } catch (std::exception& e) {
41083       {
41084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41085       };
41086     } catch (Dali::DaliException e) {
41087       {
41088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41089       };
41090     } catch (...) {
41091       {
41092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41093       };
41094     }
41095   }
41096
41097   jresult = (unsigned long)result;
41098   return jresult;
41099 }
41100
41101
41102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41103   void * jresult ;
41104   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41105   size_t arg2 ;
41106   Dali::PanGestureDetector::AngleThresholdPair result;
41107
41108   arg1 = (Dali::PanGestureDetector *)jarg1;
41109   arg2 = (size_t)jarg2;
41110   {
41111     try {
41112       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41113     } catch (std::out_of_range& e) {
41114       {
41115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41116       };
41117     } catch (std::exception& e) {
41118       {
41119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41120       };
41121     } catch (Dali::DaliException e) {
41122       {
41123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41124       };
41125     } catch (...) {
41126       {
41127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41128       };
41129     }
41130   }
41131
41132   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41133   return jresult;
41134 }
41135
41136
41137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41138   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41139
41140   arg1 = (Dali::PanGestureDetector *)jarg1;
41141   {
41142     try {
41143       (arg1)->ClearAngles();
41144     } catch (std::out_of_range& e) {
41145       {
41146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41147       };
41148     } catch (std::exception& e) {
41149       {
41150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41151       };
41152     } catch (Dali::DaliException e) {
41153       {
41154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41155       };
41156     } catch (...) {
41157       {
41158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41159       };
41160     }
41161   }
41162
41163 }
41164
41165
41166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41167   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41168   Dali::Radian arg2 ;
41169   Dali::Radian *argp2 ;
41170
41171   arg1 = (Dali::PanGestureDetector *)jarg1;
41172   argp2 = (Dali::Radian *)jarg2;
41173   if (!argp2) {
41174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41175     return ;
41176   }
41177   arg2 = *argp2;
41178   {
41179     try {
41180       (arg1)->RemoveAngle(arg2);
41181     } catch (std::out_of_range& e) {
41182       {
41183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41184       };
41185     } catch (std::exception& e) {
41186       {
41187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41188       };
41189     } catch (Dali::DaliException e) {
41190       {
41191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41192       };
41193     } catch (...) {
41194       {
41195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41196       };
41197     }
41198   }
41199
41200 }
41201
41202
41203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41204   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41205   Dali::Radian arg2 ;
41206   Dali::Radian *argp2 ;
41207
41208   arg1 = (Dali::PanGestureDetector *)jarg1;
41209   argp2 = (Dali::Radian *)jarg2;
41210   if (!argp2) {
41211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41212     return ;
41213   }
41214   arg2 = *argp2;
41215   {
41216     try {
41217       (arg1)->RemoveDirection(arg2);
41218     } catch (std::out_of_range& e) {
41219       {
41220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41221       };
41222     } catch (std::exception& e) {
41223       {
41224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41225       };
41226     } catch (Dali::DaliException e) {
41227       {
41228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41229       };
41230     } catch (...) {
41231       {
41232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41233       };
41234     }
41235   }
41236
41237 }
41238
41239
41240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41241   void * jresult ;
41242   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41243   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41244
41245   arg1 = (Dali::PanGestureDetector *)jarg1;
41246   {
41247     try {
41248       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41249     } catch (std::out_of_range& e) {
41250       {
41251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41252       };
41253     } catch (std::exception& e) {
41254       {
41255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41256       };
41257     } catch (Dali::DaliException e) {
41258       {
41259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41260       };
41261     } catch (...) {
41262       {
41263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41264       };
41265     }
41266   }
41267
41268   jresult = (void *)result;
41269   return jresult;
41270 }
41271
41272
41273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41274   Dali::PanGesture *arg1 = 0 ;
41275
41276   arg1 = (Dali::PanGesture *)jarg1;
41277   if (!arg1) {
41278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41279     return ;
41280   }
41281   {
41282     try {
41283       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41284     } catch (std::out_of_range& e) {
41285       {
41286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41287       };
41288     } catch (std::exception& e) {
41289       {
41290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41291       };
41292     } catch (Dali::DaliException e) {
41293       {
41294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41295       };
41296     } catch (...) {
41297       {
41298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41299       };
41300     }
41301   }
41302
41303 }
41304
41305
41306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41307   void * jresult ;
41308   Dali::PanGesture *result = 0 ;
41309
41310   {
41311     try {
41312       result = (Dali::PanGesture *)new Dali::PanGesture();
41313     } catch (std::out_of_range& e) {
41314       {
41315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41316       };
41317     } catch (std::exception& e) {
41318       {
41319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41320       };
41321     } catch (Dali::DaliException e) {
41322       {
41323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41324       };
41325     } catch (...) {
41326       {
41327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41328       };
41329     }
41330   }
41331
41332   jresult = (void *)result;
41333   return jresult;
41334 }
41335
41336
41337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41338   void * jresult ;
41339   Dali::Gesture::State arg1 ;
41340   Dali::PanGesture *result = 0 ;
41341
41342   arg1 = (Dali::Gesture::State)jarg1;
41343   {
41344     try {
41345       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41346     } catch (std::out_of_range& e) {
41347       {
41348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41349       };
41350     } catch (std::exception& e) {
41351       {
41352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41353       };
41354     } catch (Dali::DaliException e) {
41355       {
41356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41357       };
41358     } catch (...) {
41359       {
41360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41361       };
41362     }
41363   }
41364
41365   jresult = (void *)result;
41366   return jresult;
41367 }
41368
41369
41370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41371   void * jresult ;
41372   Dali::PanGesture *arg1 = 0 ;
41373   Dali::PanGesture *result = 0 ;
41374
41375   arg1 = (Dali::PanGesture *)jarg1;
41376   if (!arg1) {
41377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41378     return 0;
41379   }
41380   {
41381     try {
41382       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41383     } catch (std::out_of_range& e) {
41384       {
41385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (std::exception& e) {
41388       {
41389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41390       };
41391     } catch (Dali::DaliException e) {
41392       {
41393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41394       };
41395     } catch (...) {
41396       {
41397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41398       };
41399     }
41400   }
41401
41402   jresult = (void *)result;
41403   return jresult;
41404 }
41405
41406
41407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41408   void * jresult ;
41409   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41410   Dali::PanGesture *arg2 = 0 ;
41411   Dali::PanGesture *result = 0 ;
41412
41413   arg1 = (Dali::PanGesture *)jarg1;
41414   arg2 = (Dali::PanGesture *)jarg2;
41415   if (!arg2) {
41416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41417     return 0;
41418   }
41419   {
41420     try {
41421       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41422     } catch (std::out_of_range& e) {
41423       {
41424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41425       };
41426     } catch (std::exception& e) {
41427       {
41428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41429       };
41430     } catch (Dali::DaliException e) {
41431       {
41432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41433       };
41434     } catch (...) {
41435       {
41436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41437       };
41438     }
41439   }
41440
41441   jresult = (void *)result;
41442   return jresult;
41443 }
41444
41445
41446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41447   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41448
41449   arg1 = (Dali::PanGesture *)jarg1;
41450   {
41451     try {
41452       delete arg1;
41453     } catch (std::out_of_range& e) {
41454       {
41455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41456       };
41457     } catch (std::exception& e) {
41458       {
41459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41460       };
41461     } catch (Dali::DaliException e) {
41462       {
41463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41464       };
41465     } catch (...) {
41466       {
41467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41468       };
41469     }
41470   }
41471
41472 }
41473
41474
41475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41476   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41477   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41478
41479   arg1 = (Dali::PanGesture *)jarg1;
41480   arg2 = (Dali::Vector2 *)jarg2;
41481   if (arg1) (arg1)->velocity = *arg2;
41482 }
41483
41484
41485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41486   void * jresult ;
41487   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41488   Dali::Vector2 *result = 0 ;
41489
41490   arg1 = (Dali::PanGesture *)jarg1;
41491   result = (Dali::Vector2 *)& ((arg1)->velocity);
41492   jresult = (void *)result;
41493   return jresult;
41494 }
41495
41496
41497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41498   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41499   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41500
41501   arg1 = (Dali::PanGesture *)jarg1;
41502   arg2 = (Dali::Vector2 *)jarg2;
41503   if (arg1) (arg1)->displacement = *arg2;
41504 }
41505
41506
41507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41508   void * jresult ;
41509   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41510   Dali::Vector2 *result = 0 ;
41511
41512   arg1 = (Dali::PanGesture *)jarg1;
41513   result = (Dali::Vector2 *)& ((arg1)->displacement);
41514   jresult = (void *)result;
41515   return jresult;
41516 }
41517
41518
41519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41520   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41521   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41522
41523   arg1 = (Dali::PanGesture *)jarg1;
41524   arg2 = (Dali::Vector2 *)jarg2;
41525   if (arg1) (arg1)->position = *arg2;
41526 }
41527
41528
41529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41530   void * jresult ;
41531   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41532   Dali::Vector2 *result = 0 ;
41533
41534   arg1 = (Dali::PanGesture *)jarg1;
41535   result = (Dali::Vector2 *)& ((arg1)->position);
41536   jresult = (void *)result;
41537   return jresult;
41538 }
41539
41540
41541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41542   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41543   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41544
41545   arg1 = (Dali::PanGesture *)jarg1;
41546   arg2 = (Dali::Vector2 *)jarg2;
41547   if (arg1) (arg1)->screenVelocity = *arg2;
41548 }
41549
41550
41551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41552   void * jresult ;
41553   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41554   Dali::Vector2 *result = 0 ;
41555
41556   arg1 = (Dali::PanGesture *)jarg1;
41557   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41558   jresult = (void *)result;
41559   return jresult;
41560 }
41561
41562
41563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41564   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41565   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41566
41567   arg1 = (Dali::PanGesture *)jarg1;
41568   arg2 = (Dali::Vector2 *)jarg2;
41569   if (arg1) (arg1)->screenDisplacement = *arg2;
41570 }
41571
41572
41573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41574   void * jresult ;
41575   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41576   Dali::Vector2 *result = 0 ;
41577
41578   arg1 = (Dali::PanGesture *)jarg1;
41579   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41580   jresult = (void *)result;
41581   return jresult;
41582 }
41583
41584
41585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41586   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41587   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41588
41589   arg1 = (Dali::PanGesture *)jarg1;
41590   arg2 = (Dali::Vector2 *)jarg2;
41591   if (arg1) (arg1)->screenPosition = *arg2;
41592 }
41593
41594
41595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41596   void * jresult ;
41597   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41598   Dali::Vector2 *result = 0 ;
41599
41600   arg1 = (Dali::PanGesture *)jarg1;
41601   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41602   jresult = (void *)result;
41603   return jresult;
41604 }
41605
41606
41607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41608   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41609   unsigned int arg2 ;
41610
41611   arg1 = (Dali::PanGesture *)jarg1;
41612   arg2 = (unsigned int)jarg2;
41613   if (arg1) (arg1)->numberOfTouches = arg2;
41614 }
41615
41616
41617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41618   unsigned int jresult ;
41619   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41620   unsigned int result;
41621
41622   arg1 = (Dali::PanGesture *)jarg1;
41623   result = (unsigned int) ((arg1)->numberOfTouches);
41624   jresult = result;
41625   return jresult;
41626 }
41627
41628
41629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41630   float jresult ;
41631   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41632   float result;
41633
41634   arg1 = (Dali::PanGesture *)jarg1;
41635   {
41636     try {
41637       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41638     } catch (std::out_of_range& e) {
41639       {
41640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41641       };
41642     } catch (std::exception& e) {
41643       {
41644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41645       };
41646     } catch (Dali::DaliException e) {
41647       {
41648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41649       };
41650     } catch (...) {
41651       {
41652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41653       };
41654     }
41655   }
41656
41657   jresult = result;
41658   return jresult;
41659 }
41660
41661
41662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41663   float jresult ;
41664   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41665   float result;
41666
41667   arg1 = (Dali::PanGesture *)jarg1;
41668   {
41669     try {
41670       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41671     } catch (std::out_of_range& e) {
41672       {
41673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41674       };
41675     } catch (std::exception& e) {
41676       {
41677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41678       };
41679     } catch (Dali::DaliException e) {
41680       {
41681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41682       };
41683     } catch (...) {
41684       {
41685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41686       };
41687     }
41688   }
41689
41690   jresult = result;
41691   return jresult;
41692 }
41693
41694
41695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41696   float jresult ;
41697   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41698   float result;
41699
41700   arg1 = (Dali::PanGesture *)jarg1;
41701   {
41702     try {
41703       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41704     } catch (std::out_of_range& e) {
41705       {
41706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41707       };
41708     } catch (std::exception& e) {
41709       {
41710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41711       };
41712     } catch (Dali::DaliException e) {
41713       {
41714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41715       };
41716     } catch (...) {
41717       {
41718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41719       };
41720     }
41721   }
41722
41723   jresult = result;
41724   return jresult;
41725 }
41726
41727
41728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41729   float jresult ;
41730   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41731   float result;
41732
41733   arg1 = (Dali::PanGesture *)jarg1;
41734   {
41735     try {
41736       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41737     } catch (std::out_of_range& e) {
41738       {
41739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41740       };
41741     } catch (std::exception& e) {
41742       {
41743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41744       };
41745     } catch (Dali::DaliException e) {
41746       {
41747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41748       };
41749     } catch (...) {
41750       {
41751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41752       };
41753     }
41754   }
41755
41756   jresult = result;
41757   return jresult;
41758 }
41759
41760
41761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41762   void * jresult ;
41763   Dali::PinchGestureDetector *result = 0 ;
41764
41765   {
41766     try {
41767       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41768     } catch (std::out_of_range& e) {
41769       {
41770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41771       };
41772     } catch (std::exception& e) {
41773       {
41774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41775       };
41776     } catch (Dali::DaliException e) {
41777       {
41778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41779       };
41780     } catch (...) {
41781       {
41782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41783       };
41784     }
41785   }
41786
41787   jresult = (void *)result;
41788   return jresult;
41789 }
41790
41791
41792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41793   void * jresult ;
41794   Dali::PinchGestureDetector result;
41795
41796   {
41797     try {
41798       result = Dali::PinchGestureDetector::New();
41799     } catch (std::out_of_range& e) {
41800       {
41801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41802       };
41803     } catch (std::exception& e) {
41804       {
41805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41806       };
41807     } catch (Dali::DaliException e) {
41808       {
41809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41810       };
41811     } catch (...) {
41812       {
41813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41814       };
41815     }
41816   }
41817
41818   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41819   return jresult;
41820 }
41821
41822
41823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41824   void * jresult ;
41825   Dali::BaseHandle arg1 ;
41826   Dali::BaseHandle *argp1 ;
41827   Dali::PinchGestureDetector result;
41828
41829   argp1 = (Dali::BaseHandle *)jarg1;
41830   if (!argp1) {
41831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41832     return 0;
41833   }
41834   arg1 = *argp1;
41835   {
41836     try {
41837       result = Dali::PinchGestureDetector::DownCast(arg1);
41838     } catch (std::out_of_range& e) {
41839       {
41840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41841       };
41842     } catch (std::exception& e) {
41843       {
41844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41845       };
41846     } catch (Dali::DaliException e) {
41847       {
41848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41849       };
41850     } catch (...) {
41851       {
41852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41853       };
41854     }
41855   }
41856
41857   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41858   return jresult;
41859 }
41860
41861
41862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41863   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41864
41865   arg1 = (Dali::PinchGestureDetector *)jarg1;
41866   {
41867     try {
41868       delete arg1;
41869     } catch (std::out_of_range& e) {
41870       {
41871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41872       };
41873     } catch (std::exception& e) {
41874       {
41875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41876       };
41877     } catch (Dali::DaliException e) {
41878       {
41879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41880       };
41881     } catch (...) {
41882       {
41883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41884       };
41885     }
41886   }
41887
41888 }
41889
41890
41891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41892   void * jresult ;
41893   Dali::PinchGestureDetector *arg1 = 0 ;
41894   Dali::PinchGestureDetector *result = 0 ;
41895
41896   arg1 = (Dali::PinchGestureDetector *)jarg1;
41897   if (!arg1) {
41898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41899     return 0;
41900   }
41901   {
41902     try {
41903       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41904     } catch (std::out_of_range& e) {
41905       {
41906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41907       };
41908     } catch (std::exception& e) {
41909       {
41910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41911       };
41912     } catch (Dali::DaliException e) {
41913       {
41914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41915       };
41916     } catch (...) {
41917       {
41918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41919       };
41920     }
41921   }
41922
41923   jresult = (void *)result;
41924   return jresult;
41925 }
41926
41927
41928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41929   void * jresult ;
41930   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41931   Dali::PinchGestureDetector *arg2 = 0 ;
41932   Dali::PinchGestureDetector *result = 0 ;
41933
41934   arg1 = (Dali::PinchGestureDetector *)jarg1;
41935   arg2 = (Dali::PinchGestureDetector *)jarg2;
41936   if (!arg2) {
41937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41938     return 0;
41939   }
41940   {
41941     try {
41942       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41943     } catch (std::out_of_range& e) {
41944       {
41945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41946       };
41947     } catch (std::exception& e) {
41948       {
41949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41950       };
41951     } catch (Dali::DaliException e) {
41952       {
41953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41954       };
41955     } catch (...) {
41956       {
41957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41958       };
41959     }
41960   }
41961
41962   jresult = (void *)result;
41963   return jresult;
41964 }
41965
41966
41967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41968   void * jresult ;
41969   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41970   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41971
41972   arg1 = (Dali::PinchGestureDetector *)jarg1;
41973   {
41974     try {
41975       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41976     } catch (std::out_of_range& e) {
41977       {
41978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41979       };
41980     } catch (std::exception& e) {
41981       {
41982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41983       };
41984     } catch (Dali::DaliException e) {
41985       {
41986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41987       };
41988     } catch (...) {
41989       {
41990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41991       };
41992     }
41993   }
41994
41995   jresult = (void *)result;
41996   return jresult;
41997 }
41998
41999
42000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42001   void * jresult ;
42002   Dali::Gesture::State arg1 ;
42003   Dali::PinchGesture *result = 0 ;
42004
42005   arg1 = (Dali::Gesture::State)jarg1;
42006   {
42007     try {
42008       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42009     } catch (std::out_of_range& e) {
42010       {
42011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42012       };
42013     } catch (std::exception& e) {
42014       {
42015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42016       };
42017     } catch (Dali::DaliException e) {
42018       {
42019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42020       };
42021     } catch (...) {
42022       {
42023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42024       };
42025     }
42026   }
42027
42028   jresult = (void *)result;
42029   return jresult;
42030 }
42031
42032
42033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42034   void * jresult ;
42035   Dali::PinchGesture *arg1 = 0 ;
42036   Dali::PinchGesture *result = 0 ;
42037
42038   arg1 = (Dali::PinchGesture *)jarg1;
42039   if (!arg1) {
42040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42041     return 0;
42042   }
42043   {
42044     try {
42045       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42046     } catch (std::out_of_range& e) {
42047       {
42048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42049       };
42050     } catch (std::exception& e) {
42051       {
42052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42053       };
42054     } catch (Dali::DaliException e) {
42055       {
42056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42057       };
42058     } catch (...) {
42059       {
42060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42061       };
42062     }
42063   }
42064
42065   jresult = (void *)result;
42066   return jresult;
42067 }
42068
42069
42070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42071   void * jresult ;
42072   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42073   Dali::PinchGesture *arg2 = 0 ;
42074   Dali::PinchGesture *result = 0 ;
42075
42076   arg1 = (Dali::PinchGesture *)jarg1;
42077   arg2 = (Dali::PinchGesture *)jarg2;
42078   if (!arg2) {
42079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42080     return 0;
42081   }
42082   {
42083     try {
42084       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42085     } catch (std::out_of_range& e) {
42086       {
42087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42088       };
42089     } catch (std::exception& e) {
42090       {
42091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42092       };
42093     } catch (Dali::DaliException e) {
42094       {
42095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42096       };
42097     } catch (...) {
42098       {
42099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42100       };
42101     }
42102   }
42103
42104   jresult = (void *)result;
42105   return jresult;
42106 }
42107
42108
42109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42110   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42111
42112   arg1 = (Dali::PinchGesture *)jarg1;
42113   {
42114     try {
42115       delete arg1;
42116     } catch (std::out_of_range& e) {
42117       {
42118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42119       };
42120     } catch (std::exception& e) {
42121       {
42122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42123       };
42124     } catch (Dali::DaliException e) {
42125       {
42126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42127       };
42128     } catch (...) {
42129       {
42130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42131       };
42132     }
42133   }
42134
42135 }
42136
42137
42138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42139   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42140   float arg2 ;
42141
42142   arg1 = (Dali::PinchGesture *)jarg1;
42143   arg2 = (float)jarg2;
42144   if (arg1) (arg1)->scale = arg2;
42145 }
42146
42147
42148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42149   float jresult ;
42150   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42151   float result;
42152
42153   arg1 = (Dali::PinchGesture *)jarg1;
42154   result = (float) ((arg1)->scale);
42155   jresult = result;
42156   return jresult;
42157 }
42158
42159
42160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42161   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42162   float arg2 ;
42163
42164   arg1 = (Dali::PinchGesture *)jarg1;
42165   arg2 = (float)jarg2;
42166   if (arg1) (arg1)->speed = arg2;
42167 }
42168
42169
42170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42171   float jresult ;
42172   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42173   float result;
42174
42175   arg1 = (Dali::PinchGesture *)jarg1;
42176   result = (float) ((arg1)->speed);
42177   jresult = result;
42178   return jresult;
42179 }
42180
42181
42182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42183   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42184   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42185
42186   arg1 = (Dali::PinchGesture *)jarg1;
42187   arg2 = (Dali::Vector2 *)jarg2;
42188   if (arg1) (arg1)->screenCenterPoint = *arg2;
42189 }
42190
42191
42192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42193   void * jresult ;
42194   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42195   Dali::Vector2 *result = 0 ;
42196
42197   arg1 = (Dali::PinchGesture *)jarg1;
42198   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42199   jresult = (void *)result;
42200   return jresult;
42201 }
42202
42203
42204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42205   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42206   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42207
42208   arg1 = (Dali::PinchGesture *)jarg1;
42209   arg2 = (Dali::Vector2 *)jarg2;
42210   if (arg1) (arg1)->localCenterPoint = *arg2;
42211 }
42212
42213
42214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42215   void * jresult ;
42216   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42217   Dali::Vector2 *result = 0 ;
42218
42219   arg1 = (Dali::PinchGesture *)jarg1;
42220   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42221   jresult = (void *)result;
42222   return jresult;
42223 }
42224
42225
42226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42227   void * jresult ;
42228   Dali::TapGestureDetector *result = 0 ;
42229
42230   {
42231     try {
42232       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42233     } catch (std::out_of_range& e) {
42234       {
42235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42236       };
42237     } catch (std::exception& e) {
42238       {
42239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42240       };
42241     } catch (Dali::DaliException e) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42244       };
42245     } catch (...) {
42246       {
42247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42248       };
42249     }
42250   }
42251
42252   jresult = (void *)result;
42253   return jresult;
42254 }
42255
42256
42257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42258   void * jresult ;
42259   Dali::TapGestureDetector result;
42260
42261   {
42262     try {
42263       result = Dali::TapGestureDetector::New();
42264     } catch (std::out_of_range& e) {
42265       {
42266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42267       };
42268     } catch (std::exception& e) {
42269       {
42270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42271       };
42272     } catch (Dali::DaliException e) {
42273       {
42274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42275       };
42276     } catch (...) {
42277       {
42278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42279       };
42280     }
42281   }
42282
42283   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42284   return jresult;
42285 }
42286
42287
42288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42289   void * jresult ;
42290   unsigned int arg1 ;
42291   Dali::TapGestureDetector result;
42292
42293   arg1 = (unsigned int)jarg1;
42294   {
42295     try {
42296       result = Dali::TapGestureDetector::New(arg1);
42297     } catch (std::out_of_range& e) {
42298       {
42299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42300       };
42301     } catch (std::exception& e) {
42302       {
42303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42304       };
42305     } catch (Dali::DaliException e) {
42306       {
42307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42308       };
42309     } catch (...) {
42310       {
42311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42312       };
42313     }
42314   }
42315
42316   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42317   return jresult;
42318 }
42319
42320
42321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42322   void * jresult ;
42323   Dali::BaseHandle arg1 ;
42324   Dali::BaseHandle *argp1 ;
42325   Dali::TapGestureDetector result;
42326
42327   argp1 = (Dali::BaseHandle *)jarg1;
42328   if (!argp1) {
42329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42330     return 0;
42331   }
42332   arg1 = *argp1;
42333   {
42334     try {
42335       result = Dali::TapGestureDetector::DownCast(arg1);
42336     } catch (std::out_of_range& e) {
42337       {
42338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42339       };
42340     } catch (std::exception& e) {
42341       {
42342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42343       };
42344     } catch (Dali::DaliException e) {
42345       {
42346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42347       };
42348     } catch (...) {
42349       {
42350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42351       };
42352     }
42353   }
42354
42355   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42356   return jresult;
42357 }
42358
42359
42360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42361   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42362
42363   arg1 = (Dali::TapGestureDetector *)jarg1;
42364   {
42365     try {
42366       delete arg1;
42367     } catch (std::out_of_range& e) {
42368       {
42369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42370       };
42371     } catch (std::exception& e) {
42372       {
42373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42374       };
42375     } catch (Dali::DaliException e) {
42376       {
42377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42378       };
42379     } catch (...) {
42380       {
42381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42382       };
42383     }
42384   }
42385
42386 }
42387
42388
42389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42390   void * jresult ;
42391   Dali::TapGestureDetector *arg1 = 0 ;
42392   Dali::TapGestureDetector *result = 0 ;
42393
42394   arg1 = (Dali::TapGestureDetector *)jarg1;
42395   if (!arg1) {
42396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42397     return 0;
42398   }
42399   {
42400     try {
42401       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42402     } catch (std::out_of_range& e) {
42403       {
42404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42405       };
42406     } catch (std::exception& e) {
42407       {
42408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42409       };
42410     } catch (Dali::DaliException e) {
42411       {
42412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42413       };
42414     } catch (...) {
42415       {
42416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42417       };
42418     }
42419   }
42420
42421   jresult = (void *)result;
42422   return jresult;
42423 }
42424
42425
42426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42427   void * jresult ;
42428   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42429   Dali::TapGestureDetector *arg2 = 0 ;
42430   Dali::TapGestureDetector *result = 0 ;
42431
42432   arg1 = (Dali::TapGestureDetector *)jarg1;
42433   arg2 = (Dali::TapGestureDetector *)jarg2;
42434   if (!arg2) {
42435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42436     return 0;
42437   }
42438   {
42439     try {
42440       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42441     } catch (std::out_of_range& e) {
42442       {
42443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42444       };
42445     } catch (std::exception& e) {
42446       {
42447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42448       };
42449     } catch (Dali::DaliException e) {
42450       {
42451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42452       };
42453     } catch (...) {
42454       {
42455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42456       };
42457     }
42458   }
42459
42460   jresult = (void *)result;
42461   return jresult;
42462 }
42463
42464
42465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42466   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42467   unsigned int arg2 ;
42468
42469   arg1 = (Dali::TapGestureDetector *)jarg1;
42470   arg2 = (unsigned int)jarg2;
42471   {
42472     try {
42473       (arg1)->SetMinimumTapsRequired(arg2);
42474     } catch (std::out_of_range& e) {
42475       {
42476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42477       };
42478     } catch (std::exception& e) {
42479       {
42480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42481       };
42482     } catch (Dali::DaliException e) {
42483       {
42484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42485       };
42486     } catch (...) {
42487       {
42488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42489       };
42490     }
42491   }
42492
42493 }
42494
42495
42496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42497   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42498   unsigned int arg2 ;
42499
42500   arg1 = (Dali::TapGestureDetector *)jarg1;
42501   arg2 = (unsigned int)jarg2;
42502   {
42503     try {
42504       (arg1)->SetMaximumTapsRequired(arg2);
42505     } catch (std::out_of_range& e) {
42506       {
42507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42508       };
42509     } catch (std::exception& e) {
42510       {
42511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42512       };
42513     } catch (Dali::DaliException e) {
42514       {
42515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42516       };
42517     } catch (...) {
42518       {
42519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42520       };
42521     }
42522   }
42523
42524 }
42525
42526
42527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42528   unsigned int jresult ;
42529   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42530   unsigned int result;
42531
42532   arg1 = (Dali::TapGestureDetector *)jarg1;
42533   {
42534     try {
42535       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42536     } catch (std::out_of_range& e) {
42537       {
42538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42539       };
42540     } catch (std::exception& e) {
42541       {
42542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42543       };
42544     } catch (Dali::DaliException e) {
42545       {
42546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42547       };
42548     } catch (...) {
42549       {
42550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42551       };
42552     }
42553   }
42554
42555   jresult = result;
42556   return jresult;
42557 }
42558
42559
42560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42561   unsigned int jresult ;
42562   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42563   unsigned int result;
42564
42565   arg1 = (Dali::TapGestureDetector *)jarg1;
42566   {
42567     try {
42568       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42569     } catch (std::out_of_range& e) {
42570       {
42571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42572       };
42573     } catch (std::exception& e) {
42574       {
42575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42576       };
42577     } catch (Dali::DaliException e) {
42578       {
42579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42580       };
42581     } catch (...) {
42582       {
42583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42584       };
42585     }
42586   }
42587
42588   jresult = result;
42589   return jresult;
42590 }
42591
42592
42593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42594   void * jresult ;
42595   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42596   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42597
42598   arg1 = (Dali::TapGestureDetector *)jarg1;
42599   {
42600     try {
42601       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42602     } catch (std::out_of_range& e) {
42603       {
42604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42605       };
42606     } catch (std::exception& e) {
42607       {
42608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42609       };
42610     } catch (Dali::DaliException e) {
42611       {
42612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42613       };
42614     } catch (...) {
42615       {
42616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42617       };
42618     }
42619   }
42620
42621   jresult = (void *)result;
42622   return jresult;
42623 }
42624
42625
42626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42627   void * jresult ;
42628   Dali::TapGesture *result = 0 ;
42629
42630   {
42631     try {
42632       result = (Dali::TapGesture *)new Dali::TapGesture();
42633     } catch (std::out_of_range& e) {
42634       {
42635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42636       };
42637     } catch (std::exception& e) {
42638       {
42639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42640       };
42641     } catch (Dali::DaliException e) {
42642       {
42643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42644       };
42645     } catch (...) {
42646       {
42647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42648       };
42649     }
42650   }
42651
42652   jresult = (void *)result;
42653   return jresult;
42654 }
42655
42656
42657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42658   void * jresult ;
42659   Dali::TapGesture *arg1 = 0 ;
42660   Dali::TapGesture *result = 0 ;
42661
42662   arg1 = (Dali::TapGesture *)jarg1;
42663   if (!arg1) {
42664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42665     return 0;
42666   }
42667   {
42668     try {
42669       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42670     } catch (std::out_of_range& e) {
42671       {
42672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42673       };
42674     } catch (std::exception& e) {
42675       {
42676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42677       };
42678     } catch (Dali::DaliException e) {
42679       {
42680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42681       };
42682     } catch (...) {
42683       {
42684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42685       };
42686     }
42687   }
42688
42689   jresult = (void *)result;
42690   return jresult;
42691 }
42692
42693
42694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42695   void * jresult ;
42696   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42697   Dali::TapGesture *arg2 = 0 ;
42698   Dali::TapGesture *result = 0 ;
42699
42700   arg1 = (Dali::TapGesture *)jarg1;
42701   arg2 = (Dali::TapGesture *)jarg2;
42702   if (!arg2) {
42703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42704     return 0;
42705   }
42706   {
42707     try {
42708       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42709     } catch (std::out_of_range& e) {
42710       {
42711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42712       };
42713     } catch (std::exception& e) {
42714       {
42715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42716       };
42717     } catch (Dali::DaliException e) {
42718       {
42719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42720       };
42721     } catch (...) {
42722       {
42723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42724       };
42725     }
42726   }
42727
42728   jresult = (void *)result;
42729   return jresult;
42730 }
42731
42732
42733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42734   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42735
42736   arg1 = (Dali::TapGesture *)jarg1;
42737   {
42738     try {
42739       delete arg1;
42740     } catch (std::out_of_range& e) {
42741       {
42742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42743       };
42744     } catch (std::exception& e) {
42745       {
42746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42747       };
42748     } catch (Dali::DaliException e) {
42749       {
42750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42751       };
42752     } catch (...) {
42753       {
42754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42755       };
42756     }
42757   }
42758
42759 }
42760
42761
42762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42763   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42764   unsigned int arg2 ;
42765
42766   arg1 = (Dali::TapGesture *)jarg1;
42767   arg2 = (unsigned int)jarg2;
42768   if (arg1) (arg1)->numberOfTaps = arg2;
42769 }
42770
42771
42772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42773   unsigned int jresult ;
42774   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42775   unsigned int result;
42776
42777   arg1 = (Dali::TapGesture *)jarg1;
42778   result = (unsigned int) ((arg1)->numberOfTaps);
42779   jresult = result;
42780   return jresult;
42781 }
42782
42783
42784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42785   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42786   unsigned int arg2 ;
42787
42788   arg1 = (Dali::TapGesture *)jarg1;
42789   arg2 = (unsigned int)jarg2;
42790   if (arg1) (arg1)->numberOfTouches = arg2;
42791 }
42792
42793
42794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42795   unsigned int jresult ;
42796   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42797   unsigned int result;
42798
42799   arg1 = (Dali::TapGesture *)jarg1;
42800   result = (unsigned int) ((arg1)->numberOfTouches);
42801   jresult = result;
42802   return jresult;
42803 }
42804
42805
42806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42807   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42808   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42809
42810   arg1 = (Dali::TapGesture *)jarg1;
42811   arg2 = (Dali::Vector2 *)jarg2;
42812   if (arg1) (arg1)->screenPoint = *arg2;
42813 }
42814
42815
42816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42817   void * jresult ;
42818   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42819   Dali::Vector2 *result = 0 ;
42820
42821   arg1 = (Dali::TapGesture *)jarg1;
42822   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42823   jresult = (void *)result;
42824   return jresult;
42825 }
42826
42827
42828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42829   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42830   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42831
42832   arg1 = (Dali::TapGesture *)jarg1;
42833   arg2 = (Dali::Vector2 *)jarg2;
42834   if (arg1) (arg1)->localPoint = *arg2;
42835 }
42836
42837
42838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42839   void * jresult ;
42840   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42841   Dali::Vector2 *result = 0 ;
42842
42843   arg1 = (Dali::TapGesture *)jarg1;
42844   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42845   jresult = (void *)result;
42846   return jresult;
42847 }
42848
42849
42850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42851   void * jresult ;
42852   Dali::AlphaFunction *result = 0 ;
42853
42854   {
42855     try {
42856       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42857     } catch (std::out_of_range& e) {
42858       {
42859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42860       };
42861     } catch (std::exception& e) {
42862       {
42863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42864       };
42865     } catch (Dali::DaliException e) {
42866       {
42867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42868       };
42869     } catch (...) {
42870       {
42871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42872       };
42873     }
42874   }
42875
42876   jresult = (void *)result;
42877   return jresult;
42878 }
42879
42880
42881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42882   void * jresult ;
42883   Dali::AlphaFunction::BuiltinFunction arg1 ;
42884   Dali::AlphaFunction *result = 0 ;
42885
42886   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42887   {
42888     try {
42889       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42890     } catch (std::out_of_range& e) {
42891       {
42892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42893       };
42894     } catch (std::exception& e) {
42895       {
42896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42897       };
42898     } catch (Dali::DaliException e) {
42899       {
42900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42901       };
42902     } catch (...) {
42903       {
42904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42905       };
42906     }
42907   }
42908
42909   jresult = (void *)result;
42910   return jresult;
42911 }
42912
42913
42914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42915   void * jresult ;
42916   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42917   Dali::AlphaFunction *result = 0 ;
42918
42919   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42920   {
42921     try {
42922       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42923     } catch (std::out_of_range& e) {
42924       {
42925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42926       };
42927     } catch (std::exception& e) {
42928       {
42929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42930       };
42931     } catch (Dali::DaliException e) {
42932       {
42933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42934       };
42935     } catch (...) {
42936       {
42937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42938       };
42939     }
42940   }
42941
42942   jresult = (void *)result;
42943   return jresult;
42944 }
42945
42946
42947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42948   void * jresult ;
42949   Dali::Vector2 *arg1 = 0 ;
42950   Dali::Vector2 *arg2 = 0 ;
42951   Dali::AlphaFunction *result = 0 ;
42952
42953   arg1 = (Dali::Vector2 *)jarg1;
42954   if (!arg1) {
42955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42956     return 0;
42957   }
42958   arg2 = (Dali::Vector2 *)jarg2;
42959   if (!arg2) {
42960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42961     return 0;
42962   }
42963   {
42964     try {
42965       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42966     } catch (std::out_of_range& e) {
42967       {
42968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42969       };
42970     } catch (std::exception& e) {
42971       {
42972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42973       };
42974     } catch (Dali::DaliException e) {
42975       {
42976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42977       };
42978     } catch (...) {
42979       {
42980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42981       };
42982     }
42983   }
42984
42985   jresult = (void *)result;
42986   return jresult;
42987 }
42988
42989
42990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42991   void * jresult ;
42992   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42993   Dali::Vector4 result;
42994
42995   arg1 = (Dali::AlphaFunction *)jarg1;
42996   {
42997     try {
42998       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42999     } catch (std::out_of_range& e) {
43000       {
43001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43002       };
43003     } catch (std::exception& e) {
43004       {
43005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43006       };
43007     } catch (Dali::DaliException e) {
43008       {
43009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43010       };
43011     } catch (...) {
43012       {
43013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43014       };
43015     }
43016   }
43017
43018   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43019   return jresult;
43020 }
43021
43022
43023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43024   void * jresult ;
43025   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43026   Dali::AlphaFunctionPrototype result;
43027
43028   arg1 = (Dali::AlphaFunction *)jarg1;
43029   {
43030     try {
43031       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43032     } catch (std::out_of_range& e) {
43033       {
43034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43035       };
43036     } catch (std::exception& e) {
43037       {
43038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43039       };
43040     } catch (Dali::DaliException e) {
43041       {
43042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43043       };
43044     } catch (...) {
43045       {
43046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43047       };
43048     }
43049   }
43050
43051   jresult = (void *)result;
43052   return jresult;
43053 }
43054
43055
43056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43057   int jresult ;
43058   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43059   Dali::AlphaFunction::BuiltinFunction result;
43060
43061   arg1 = (Dali::AlphaFunction *)jarg1;
43062   {
43063     try {
43064       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43065     } catch (std::out_of_range& e) {
43066       {
43067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43068       };
43069     } catch (std::exception& e) {
43070       {
43071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43072       };
43073     } catch (Dali::DaliException e) {
43074       {
43075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43076       };
43077     } catch (...) {
43078       {
43079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43080       };
43081     }
43082   }
43083
43084   jresult = (int)result;
43085   return jresult;
43086 }
43087
43088
43089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43090   int jresult ;
43091   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43092   Dali::AlphaFunction::Mode result;
43093
43094   arg1 = (Dali::AlphaFunction *)jarg1;
43095   {
43096     try {
43097       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43098     } catch (std::out_of_range& e) {
43099       {
43100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43101       };
43102     } catch (std::exception& e) {
43103       {
43104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43105       };
43106     } catch (Dali::DaliException e) {
43107       {
43108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43109       };
43110     } catch (...) {
43111       {
43112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43113       };
43114     }
43115   }
43116
43117   jresult = (int)result;
43118   return jresult;
43119 }
43120
43121
43122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43123   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43124
43125   arg1 = (Dali::AlphaFunction *)jarg1;
43126   {
43127     try {
43128       delete arg1;
43129     } catch (std::out_of_range& e) {
43130       {
43131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43132       };
43133     } catch (std::exception& e) {
43134       {
43135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43136       };
43137     } catch (Dali::DaliException e) {
43138       {
43139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43140       };
43141     } catch (...) {
43142       {
43143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43144       };
43145     }
43146   }
43147
43148 }
43149
43150
43151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43152   void * jresult ;
43153   Dali::KeyFrames result;
43154
43155   {
43156     try {
43157       result = Dali::KeyFrames::New();
43158     } catch (std::out_of_range& e) {
43159       {
43160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43161       };
43162     } catch (std::exception& e) {
43163       {
43164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43165       };
43166     } catch (Dali::DaliException e) {
43167       {
43168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43169       };
43170     } catch (...) {
43171       {
43172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43173       };
43174     }
43175   }
43176
43177   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43178   return jresult;
43179 }
43180
43181
43182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43183   void * jresult ;
43184   Dali::BaseHandle arg1 ;
43185   Dali::BaseHandle *argp1 ;
43186   Dali::KeyFrames result;
43187
43188   argp1 = (Dali::BaseHandle *)jarg1;
43189   if (!argp1) {
43190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43191     return 0;
43192   }
43193   arg1 = *argp1;
43194   {
43195     try {
43196       result = Dali::KeyFrames::DownCast(arg1);
43197     } catch (std::out_of_range& e) {
43198       {
43199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43200       };
43201     } catch (std::exception& e) {
43202       {
43203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43204       };
43205     } catch (Dali::DaliException e) {
43206       {
43207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43208       };
43209     } catch (...) {
43210       {
43211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43212       };
43213     }
43214   }
43215
43216   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43217   return jresult;
43218 }
43219
43220
43221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43222   void * jresult ;
43223   Dali::KeyFrames *result = 0 ;
43224
43225   {
43226     try {
43227       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43228     } catch (std::out_of_range& e) {
43229       {
43230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43231       };
43232     } catch (std::exception& e) {
43233       {
43234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43235       };
43236     } catch (Dali::DaliException e) {
43237       {
43238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43239       };
43240     } catch (...) {
43241       {
43242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43243       };
43244     }
43245   }
43246
43247   jresult = (void *)result;
43248   return jresult;
43249 }
43250
43251
43252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43253   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43254
43255   arg1 = (Dali::KeyFrames *)jarg1;
43256   {
43257     try {
43258       delete arg1;
43259     } catch (std::out_of_range& e) {
43260       {
43261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43262       };
43263     } catch (std::exception& e) {
43264       {
43265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43266       };
43267     } catch (Dali::DaliException e) {
43268       {
43269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43270       };
43271     } catch (...) {
43272       {
43273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43274       };
43275     }
43276   }
43277
43278 }
43279
43280
43281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43282   void * jresult ;
43283   Dali::KeyFrames *arg1 = 0 ;
43284   Dali::KeyFrames *result = 0 ;
43285
43286   arg1 = (Dali::KeyFrames *)jarg1;
43287   if (!arg1) {
43288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43289     return 0;
43290   }
43291   {
43292     try {
43293       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43294     } catch (std::out_of_range& e) {
43295       {
43296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43297       };
43298     } catch (std::exception& e) {
43299       {
43300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43301       };
43302     } catch (Dali::DaliException e) {
43303       {
43304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43305       };
43306     } catch (...) {
43307       {
43308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43309       };
43310     }
43311   }
43312
43313   jresult = (void *)result;
43314   return jresult;
43315 }
43316
43317
43318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43319   void * jresult ;
43320   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43321   Dali::KeyFrames *arg2 = 0 ;
43322   Dali::KeyFrames *result = 0 ;
43323
43324   arg1 = (Dali::KeyFrames *)jarg1;
43325   arg2 = (Dali::KeyFrames *)jarg2;
43326   if (!arg2) {
43327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43328     return 0;
43329   }
43330   {
43331     try {
43332       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43333     } catch (std::out_of_range& e) {
43334       {
43335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43336       };
43337     } catch (std::exception& e) {
43338       {
43339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43340       };
43341     } catch (Dali::DaliException e) {
43342       {
43343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43344       };
43345     } catch (...) {
43346       {
43347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43348       };
43349     }
43350   }
43351
43352   jresult = (void *)result;
43353   return jresult;
43354 }
43355
43356
43357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43358   int jresult ;
43359   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43360   Dali::Property::Type result;
43361
43362   arg1 = (Dali::KeyFrames *)jarg1;
43363   {
43364     try {
43365       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43366     } catch (std::out_of_range& e) {
43367       {
43368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43369       };
43370     } catch (std::exception& e) {
43371       {
43372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43373       };
43374     } catch (Dali::DaliException e) {
43375       {
43376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43377       };
43378     } catch (...) {
43379       {
43380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43381       };
43382     }
43383   }
43384
43385   jresult = (int)result;
43386   return jresult;
43387 }
43388
43389
43390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43391   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43392   float arg2 ;
43393   Dali::Property::Value arg3 ;
43394   Dali::Property::Value *argp3 ;
43395
43396   arg1 = (Dali::KeyFrames *)jarg1;
43397   arg2 = (float)jarg2;
43398   argp3 = (Dali::Property::Value *)jarg3;
43399   if (!argp3) {
43400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43401     return ;
43402   }
43403   arg3 = *argp3;
43404   {
43405     try {
43406       (arg1)->Add(arg2,arg3);
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43414       };
43415     } catch (Dali::DaliException e) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43418       };
43419     } catch (...) {
43420       {
43421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43422       };
43423     }
43424   }
43425
43426 }
43427
43428
43429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43430   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43431   float arg2 ;
43432   Dali::Property::Value arg3 ;
43433   Dali::AlphaFunction arg4 ;
43434   Dali::Property::Value *argp3 ;
43435   Dali::AlphaFunction *argp4 ;
43436
43437   arg1 = (Dali::KeyFrames *)jarg1;
43438   arg2 = (float)jarg2;
43439   argp3 = (Dali::Property::Value *)jarg3;
43440   if (!argp3) {
43441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43442     return ;
43443   }
43444   arg3 = *argp3;
43445   argp4 = (Dali::AlphaFunction *)jarg4;
43446   if (!argp4) {
43447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43448     return ;
43449   }
43450   arg4 = *argp4;
43451   {
43452     try {
43453       (arg1)->Add(arg2,arg3,arg4);
43454     } catch (std::out_of_range& e) {
43455       {
43456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43457       };
43458     } catch (std::exception& e) {
43459       {
43460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43461       };
43462     } catch (Dali::DaliException e) {
43463       {
43464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43465       };
43466     } catch (...) {
43467       {
43468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43469       };
43470     }
43471   }
43472
43473 }
43474
43475
43476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43477   int jresult ;
43478   int result;
43479
43480   result = (int)Dali::Path::Property::POINTS;
43481   jresult = (int)result;
43482   return jresult;
43483 }
43484
43485
43486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43487   int jresult ;
43488   int result;
43489
43490   result = (int)Dali::Path::Property::CONTROL_POINTS;
43491   jresult = (int)result;
43492   return jresult;
43493 }
43494
43495
43496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43497   void * jresult ;
43498   Dali::Path::Property *result = 0 ;
43499
43500   {
43501     try {
43502       result = (Dali::Path::Property *)new Dali::Path::Property();
43503     } catch (std::out_of_range& e) {
43504       {
43505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43506       };
43507     } catch (std::exception& e) {
43508       {
43509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43510       };
43511     } catch (Dali::DaliException e) {
43512       {
43513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43514       };
43515     } catch (...) {
43516       {
43517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43518       };
43519     }
43520   }
43521
43522   jresult = (void *)result;
43523   return jresult;
43524 }
43525
43526
43527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43528   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43529
43530   arg1 = (Dali::Path::Property *)jarg1;
43531   {
43532     try {
43533       delete arg1;
43534     } catch (std::out_of_range& e) {
43535       {
43536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43537       };
43538     } catch (std::exception& e) {
43539       {
43540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43541       };
43542     } catch (Dali::DaliException e) {
43543       {
43544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43545       };
43546     } catch (...) {
43547       {
43548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43549       };
43550     }
43551   }
43552
43553 }
43554
43555
43556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43557   void * jresult ;
43558   Dali::Path result;
43559
43560   {
43561     try {
43562       result = Dali::Path::New();
43563     } catch (std::out_of_range& e) {
43564       {
43565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43566       };
43567     } catch (std::exception& e) {
43568       {
43569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43570       };
43571     } catch (Dali::DaliException e) {
43572       {
43573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43574       };
43575     } catch (...) {
43576       {
43577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43578       };
43579     }
43580   }
43581
43582   jresult = new Dali::Path((const Dali::Path &)result);
43583   return jresult;
43584 }
43585
43586
43587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43588   void * jresult ;
43589   Dali::BaseHandle arg1 ;
43590   Dali::BaseHandle *argp1 ;
43591   Dali::Path result;
43592
43593   argp1 = (Dali::BaseHandle *)jarg1;
43594   if (!argp1) {
43595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43596     return 0;
43597   }
43598   arg1 = *argp1;
43599   {
43600     try {
43601       result = Dali::Path::DownCast(arg1);
43602     } catch (std::out_of_range& e) {
43603       {
43604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43605       };
43606     } catch (std::exception& e) {
43607       {
43608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43609       };
43610     } catch (Dali::DaliException e) {
43611       {
43612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43613       };
43614     } catch (...) {
43615       {
43616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43617       };
43618     }
43619   }
43620
43621   jresult = new Dali::Path((const Dali::Path &)result);
43622   return jresult;
43623 }
43624
43625
43626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43627   void * jresult ;
43628   Dali::Path *result = 0 ;
43629
43630   {
43631     try {
43632       result = (Dali::Path *)new Dali::Path();
43633     } catch (std::out_of_range& e) {
43634       {
43635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43636       };
43637     } catch (std::exception& e) {
43638       {
43639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43640       };
43641     } catch (Dali::DaliException e) {
43642       {
43643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43644       };
43645     } catch (...) {
43646       {
43647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43648       };
43649     }
43650   }
43651
43652   jresult = (void *)result;
43653   return jresult;
43654 }
43655
43656
43657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43658   Dali::Path *arg1 = (Dali::Path *) 0 ;
43659
43660   arg1 = (Dali::Path *)jarg1;
43661   {
43662     try {
43663       delete arg1;
43664     } catch (std::out_of_range& e) {
43665       {
43666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43667       };
43668     } catch (std::exception& e) {
43669       {
43670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43671       };
43672     } catch (Dali::DaliException e) {
43673       {
43674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43675       };
43676     } catch (...) {
43677       {
43678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43679       };
43680     }
43681   }
43682
43683 }
43684
43685
43686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43687   void * jresult ;
43688   Dali::Path *arg1 = 0 ;
43689   Dali::Path *result = 0 ;
43690
43691   arg1 = (Dali::Path *)jarg1;
43692   if (!arg1) {
43693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43694     return 0;
43695   }
43696   {
43697     try {
43698       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43699     } catch (std::out_of_range& e) {
43700       {
43701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43702       };
43703     } catch (std::exception& e) {
43704       {
43705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43706       };
43707     } catch (Dali::DaliException e) {
43708       {
43709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43710       };
43711     } catch (...) {
43712       {
43713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43714       };
43715     }
43716   }
43717
43718   jresult = (void *)result;
43719   return jresult;
43720 }
43721
43722
43723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43724   void * jresult ;
43725   Dali::Path *arg1 = (Dali::Path *) 0 ;
43726   Dali::Path *arg2 = 0 ;
43727   Dali::Path *result = 0 ;
43728
43729   arg1 = (Dali::Path *)jarg1;
43730   arg2 = (Dali::Path *)jarg2;
43731   if (!arg2) {
43732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43733     return 0;
43734   }
43735   {
43736     try {
43737       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43738     } catch (std::out_of_range& e) {
43739       {
43740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43741       };
43742     } catch (std::exception& e) {
43743       {
43744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43745       };
43746     } catch (Dali::DaliException e) {
43747       {
43748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43749       };
43750     } catch (...) {
43751       {
43752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43753       };
43754     }
43755   }
43756
43757   jresult = (void *)result;
43758   return jresult;
43759 }
43760
43761
43762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43763   Dali::Path *arg1 = (Dali::Path *) 0 ;
43764   Dali::Vector3 *arg2 = 0 ;
43765
43766   arg1 = (Dali::Path *)jarg1;
43767   arg2 = (Dali::Vector3 *)jarg2;
43768   if (!arg2) {
43769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43770     return ;
43771   }
43772   {
43773     try {
43774       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43775     } catch (std::out_of_range& e) {
43776       {
43777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43778       };
43779     } catch (std::exception& e) {
43780       {
43781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43782       };
43783     } catch (Dali::DaliException e) {
43784       {
43785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43786       };
43787     } catch (...) {
43788       {
43789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43790       };
43791     }
43792   }
43793
43794 }
43795
43796
43797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43798   Dali::Path *arg1 = (Dali::Path *) 0 ;
43799   Dali::Vector3 *arg2 = 0 ;
43800
43801   arg1 = (Dali::Path *)jarg1;
43802   arg2 = (Dali::Vector3 *)jarg2;
43803   if (!arg2) {
43804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43805     return ;
43806   }
43807   {
43808     try {
43809       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43810     } catch (std::out_of_range& e) {
43811       {
43812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43813       };
43814     } catch (std::exception& e) {
43815       {
43816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43817       };
43818     } catch (Dali::DaliException e) {
43819       {
43820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43821       };
43822     } catch (...) {
43823       {
43824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43825       };
43826     }
43827   }
43828
43829 }
43830
43831
43832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43833   Dali::Path *arg1 = (Dali::Path *) 0 ;
43834   float arg2 ;
43835
43836   arg1 = (Dali::Path *)jarg1;
43837   arg2 = (float)jarg2;
43838   {
43839     try {
43840       (arg1)->GenerateControlPoints(arg2);
43841     } catch (std::out_of_range& e) {
43842       {
43843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43844       };
43845     } catch (std::exception& e) {
43846       {
43847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43848       };
43849     } catch (Dali::DaliException e) {
43850       {
43851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43852       };
43853     } catch (...) {
43854       {
43855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43856       };
43857     }
43858   }
43859
43860 }
43861
43862
43863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43864   Dali::Path *arg1 = (Dali::Path *) 0 ;
43865   float arg2 ;
43866   Dali::Vector3 *arg3 = 0 ;
43867   Dali::Vector3 *arg4 = 0 ;
43868
43869   arg1 = (Dali::Path *)jarg1;
43870   arg2 = (float)jarg2;
43871   arg3 = (Dali::Vector3 *)jarg3;
43872   if (!arg3) {
43873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43874     return ;
43875   }
43876   arg4 = (Dali::Vector3 *)jarg4;
43877   if (!arg4) {
43878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43879     return ;
43880   }
43881   {
43882     try {
43883       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43884     } catch (std::out_of_range& e) {
43885       {
43886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43887       };
43888     } catch (std::exception& e) {
43889       {
43890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43891       };
43892     } catch (Dali::DaliException e) {
43893       {
43894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43895       };
43896     } catch (...) {
43897       {
43898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43899       };
43900     }
43901   }
43902
43903 }
43904
43905
43906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43907   void * jresult ;
43908   Dali::Path *arg1 = (Dali::Path *) 0 ;
43909   size_t arg2 ;
43910   Dali::Vector3 *result = 0 ;
43911
43912   arg1 = (Dali::Path *)jarg1;
43913   arg2 = (size_t)jarg2;
43914   {
43915     try {
43916       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43917     } catch (std::out_of_range& e) {
43918       {
43919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43920       };
43921     } catch (std::exception& e) {
43922       {
43923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43924       };
43925     } catch (Dali::DaliException e) {
43926       {
43927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43928       };
43929     } catch (...) {
43930       {
43931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43932       };
43933     }
43934   }
43935
43936   jresult = (void *)result;
43937   return jresult;
43938 }
43939
43940
43941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43942   void * jresult ;
43943   Dali::Path *arg1 = (Dali::Path *) 0 ;
43944   size_t arg2 ;
43945   Dali::Vector3 *result = 0 ;
43946
43947   arg1 = (Dali::Path *)jarg1;
43948   arg2 = (size_t)jarg2;
43949   {
43950     try {
43951       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43952     } catch (std::out_of_range& e) {
43953       {
43954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43955       };
43956     } catch (std::exception& e) {
43957       {
43958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43959       };
43960     } catch (Dali::DaliException e) {
43961       {
43962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43963       };
43964     } catch (...) {
43965       {
43966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43967       };
43968     }
43969   }
43970
43971   jresult = (void *)result;
43972   return jresult;
43973 }
43974
43975
43976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43977   unsigned long jresult ;
43978   Dali::Path *arg1 = (Dali::Path *) 0 ;
43979   size_t result;
43980
43981   arg1 = (Dali::Path *)jarg1;
43982   {
43983     try {
43984       result = ((Dali::Path const *)arg1)->GetPointCount();
43985     } catch (std::out_of_range& e) {
43986       {
43987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43988       };
43989     } catch (std::exception& e) {
43990       {
43991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43992       };
43993     } catch (Dali::DaliException e) {
43994       {
43995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43996       };
43997     } catch (...) {
43998       {
43999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44000       };
44001     }
44002   }
44003
44004   jresult = (unsigned long)result;
44005   return jresult;
44006 }
44007
44008
44009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44010   void * jresult ;
44011   float arg1 ;
44012   Dali::TimePeriod *result = 0 ;
44013
44014   arg1 = (float)jarg1;
44015   {
44016     try {
44017       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44018     } catch (std::out_of_range& e) {
44019       {
44020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44021       };
44022     } catch (std::exception& e) {
44023       {
44024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44025       };
44026     } catch (Dali::DaliException e) {
44027       {
44028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44029       };
44030     } catch (...) {
44031       {
44032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44033       };
44034     }
44035   }
44036
44037   jresult = (void *)result;
44038   return jresult;
44039 }
44040
44041
44042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44043   void * jresult ;
44044   float arg1 ;
44045   float arg2 ;
44046   Dali::TimePeriod *result = 0 ;
44047
44048   arg1 = (float)jarg1;
44049   arg2 = (float)jarg2;
44050   {
44051     try {
44052       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44053     } catch (std::out_of_range& e) {
44054       {
44055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44056       };
44057     } catch (std::exception& e) {
44058       {
44059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44060       };
44061     } catch (Dali::DaliException e) {
44062       {
44063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44064       };
44065     } catch (...) {
44066       {
44067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44068       };
44069     }
44070   }
44071
44072   jresult = (void *)result;
44073   return jresult;
44074 }
44075
44076
44077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44078   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44079
44080   arg1 = (Dali::TimePeriod *)jarg1;
44081   {
44082     try {
44083       delete arg1;
44084     } catch (std::out_of_range& e) {
44085       {
44086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44087       };
44088     } catch (std::exception& e) {
44089       {
44090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44091       };
44092     } catch (Dali::DaliException e) {
44093       {
44094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44095       };
44096     } catch (...) {
44097       {
44098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44099       };
44100     }
44101   }
44102
44103 }
44104
44105
44106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44107   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44108   float arg2 ;
44109
44110   arg1 = (Dali::TimePeriod *)jarg1;
44111   arg2 = (float)jarg2;
44112   if (arg1) (arg1)->delaySeconds = arg2;
44113 }
44114
44115
44116 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44117   float jresult ;
44118   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44119   float result;
44120
44121   arg1 = (Dali::TimePeriod *)jarg1;
44122   result = (float) ((arg1)->delaySeconds);
44123   jresult = result;
44124   return jresult;
44125 }
44126
44127
44128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44129   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44130   float arg2 ;
44131
44132   arg1 = (Dali::TimePeriod *)jarg1;
44133   arg2 = (float)jarg2;
44134   if (arg1) (arg1)->durationSeconds = arg2;
44135 }
44136
44137
44138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44139   float jresult ;
44140   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44141   float result;
44142
44143   arg1 = (Dali::TimePeriod *)jarg1;
44144   result = (float) ((arg1)->durationSeconds);
44145   jresult = result;
44146   return jresult;
44147 }
44148
44149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44150   int jresult ;
44151   int result;
44152
44153   result = (int)Dali::LinearConstrainer::Property::VALUE;
44154   jresult = (int)result;
44155   return jresult;
44156 }
44157
44158
44159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44160   int jresult ;
44161   int result;
44162
44163   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44164   jresult = (int)result;
44165   return jresult;
44166 }
44167
44168
44169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44170   void * jresult ;
44171   Dali::LinearConstrainer::Property *result = 0 ;
44172
44173   {
44174     try {
44175       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44176     } catch (std::out_of_range& e) {
44177       {
44178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44179       };
44180     } catch (std::exception& e) {
44181       {
44182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44183       };
44184     } catch (Dali::DaliException e) {
44185       {
44186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44187       };
44188     } catch (...) {
44189       {
44190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44191       };
44192     }
44193   }
44194
44195   jresult = (void *)result;
44196   return jresult;
44197 }
44198
44199
44200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44201   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44202
44203   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44204   {
44205     try {
44206       delete arg1;
44207     } catch (std::out_of_range& e) {
44208       {
44209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44210       };
44211     } catch (std::exception& e) {
44212       {
44213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44214       };
44215     } catch (Dali::DaliException e) {
44216       {
44217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44218       };
44219     } catch (...) {
44220       {
44221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44222       };
44223     }
44224   }
44225
44226 }
44227
44228
44229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44230   void * jresult ;
44231   Dali::LinearConstrainer result;
44232
44233   {
44234     try {
44235       result = Dali::LinearConstrainer::New();
44236     } catch (std::out_of_range& e) {
44237       {
44238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44239       };
44240     } catch (std::exception& e) {
44241       {
44242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44243       };
44244     } catch (Dali::DaliException e) {
44245       {
44246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44247       };
44248     } catch (...) {
44249       {
44250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44251       };
44252     }
44253   }
44254
44255   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44256   return jresult;
44257 }
44258
44259
44260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44261   void * jresult ;
44262   Dali::BaseHandle arg1 ;
44263   Dali::BaseHandle *argp1 ;
44264   Dali::LinearConstrainer result;
44265
44266   argp1 = (Dali::BaseHandle *)jarg1;
44267   if (!argp1) {
44268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44269     return 0;
44270   }
44271   arg1 = *argp1;
44272   {
44273     try {
44274       result = Dali::LinearConstrainer::DownCast(arg1);
44275     } catch (std::out_of_range& e) {
44276       {
44277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44278       };
44279     } catch (std::exception& e) {
44280       {
44281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44282       };
44283     } catch (Dali::DaliException e) {
44284       {
44285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44286       };
44287     } catch (...) {
44288       {
44289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44290       };
44291     }
44292   }
44293
44294   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44295   return jresult;
44296 }
44297
44298
44299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44300   void * jresult ;
44301   Dali::LinearConstrainer *result = 0 ;
44302
44303   {
44304     try {
44305       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44306     } catch (std::out_of_range& e) {
44307       {
44308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44309       };
44310     } catch (std::exception& e) {
44311       {
44312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44313       };
44314     } catch (Dali::DaliException e) {
44315       {
44316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44317       };
44318     } catch (...) {
44319       {
44320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44321       };
44322     }
44323   }
44324
44325   jresult = (void *)result;
44326   return jresult;
44327 }
44328
44329
44330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44331   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44332
44333   arg1 = (Dali::LinearConstrainer *)jarg1;
44334   {
44335     try {
44336       delete arg1;
44337     } catch (std::out_of_range& e) {
44338       {
44339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44340       };
44341     } catch (std::exception& e) {
44342       {
44343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44344       };
44345     } catch (Dali::DaliException e) {
44346       {
44347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44348       };
44349     } catch (...) {
44350       {
44351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44352       };
44353     }
44354   }
44355
44356 }
44357
44358
44359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44360   void * jresult ;
44361   Dali::LinearConstrainer *arg1 = 0 ;
44362   Dali::LinearConstrainer *result = 0 ;
44363
44364   arg1 = (Dali::LinearConstrainer *)jarg1;
44365   if (!arg1) {
44366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44367     return 0;
44368   }
44369   {
44370     try {
44371       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44372     } catch (std::out_of_range& e) {
44373       {
44374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44375       };
44376     } catch (std::exception& e) {
44377       {
44378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44379       };
44380     } catch (Dali::DaliException e) {
44381       {
44382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44383       };
44384     } catch (...) {
44385       {
44386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44387       };
44388     }
44389   }
44390
44391   jresult = (void *)result;
44392   return jresult;
44393 }
44394
44395
44396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44397   void * jresult ;
44398   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44399   Dali::LinearConstrainer *arg2 = 0 ;
44400   Dali::LinearConstrainer *result = 0 ;
44401
44402   arg1 = (Dali::LinearConstrainer *)jarg1;
44403   arg2 = (Dali::LinearConstrainer *)jarg2;
44404   if (!arg2) {
44405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44406     return 0;
44407   }
44408   {
44409     try {
44410       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44411     } catch (std::out_of_range& e) {
44412       {
44413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44414       };
44415     } catch (std::exception& e) {
44416       {
44417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44418       };
44419     } catch (Dali::DaliException e) {
44420       {
44421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44422       };
44423     } catch (...) {
44424       {
44425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44426       };
44427     }
44428   }
44429
44430   jresult = (void *)result;
44431   return jresult;
44432 }
44433
44434
44435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44436   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44437   SwigValueWrapper< Dali::Property > arg2 ;
44438   SwigValueWrapper< Dali::Property > arg3 ;
44439   Dali::Vector2 *arg4 = 0 ;
44440   Dali::Vector2 *arg5 = 0 ;
44441   Dali::Property *argp2 ;
44442   Dali::Property *argp3 ;
44443
44444   arg1 = (Dali::LinearConstrainer *)jarg1;
44445   argp2 = (Dali::Property *)jarg2;
44446   if (!argp2) {
44447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44448     return ;
44449   }
44450   arg2 = *argp2;
44451   argp3 = (Dali::Property *)jarg3;
44452   if (!argp3) {
44453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44454     return ;
44455   }
44456   arg3 = *argp3;
44457   arg4 = (Dali::Vector2 *)jarg4;
44458   if (!arg4) {
44459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44460     return ;
44461   }
44462   arg5 = (Dali::Vector2 *)jarg5;
44463   if (!arg5) {
44464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44465     return ;
44466   }
44467   {
44468     try {
44469       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44470     } catch (std::out_of_range& e) {
44471       {
44472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44473       };
44474     } catch (std::exception& e) {
44475       {
44476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44477       };
44478     } catch (Dali::DaliException e) {
44479       {
44480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44481       };
44482     } catch (...) {
44483       {
44484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44485       };
44486     }
44487   }
44488
44489 }
44490
44491
44492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44493   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44494   SwigValueWrapper< Dali::Property > arg2 ;
44495   SwigValueWrapper< Dali::Property > arg3 ;
44496   Dali::Vector2 *arg4 = 0 ;
44497   Dali::Property *argp2 ;
44498   Dali::Property *argp3 ;
44499
44500   arg1 = (Dali::LinearConstrainer *)jarg1;
44501   argp2 = (Dali::Property *)jarg2;
44502   if (!argp2) {
44503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44504     return ;
44505   }
44506   arg2 = *argp2;
44507   argp3 = (Dali::Property *)jarg3;
44508   if (!argp3) {
44509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44510     return ;
44511   }
44512   arg3 = *argp3;
44513   arg4 = (Dali::Vector2 *)jarg4;
44514   if (!arg4) {
44515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44516     return ;
44517   }
44518   {
44519     try {
44520       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44521     } catch (std::out_of_range& e) {
44522       {
44523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44524       };
44525     } catch (std::exception& e) {
44526       {
44527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44528       };
44529     } catch (Dali::DaliException e) {
44530       {
44531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44532       };
44533     } catch (...) {
44534       {
44535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44536       };
44537     }
44538   }
44539
44540 }
44541
44542
44543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44544   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44545   Dali::Handle *arg2 = 0 ;
44546
44547   arg1 = (Dali::LinearConstrainer *)jarg1;
44548   arg2 = (Dali::Handle *)jarg2;
44549   if (!arg2) {
44550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44551     return ;
44552   }
44553   {
44554     try {
44555       (arg1)->Remove(*arg2);
44556     } catch (std::out_of_range& e) {
44557       {
44558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44559       };
44560     } catch (std::exception& e) {
44561       {
44562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44563       };
44564     } catch (Dali::DaliException e) {
44565       {
44566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44567       };
44568     } catch (...) {
44569       {
44570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44571       };
44572     }
44573   }
44574
44575 }
44576
44577
44578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44579   int jresult ;
44580   int result;
44581
44582   result = (int)Dali::PathConstrainer::Property::FORWARD;
44583   jresult = (int)result;
44584   return jresult;
44585 }
44586
44587
44588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44589   int jresult ;
44590   int result;
44591
44592   result = (int)Dali::PathConstrainer::Property::POINTS;
44593   jresult = (int)result;
44594   return jresult;
44595 }
44596
44597
44598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44599   int jresult ;
44600   int result;
44601
44602   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44603   jresult = (int)result;
44604   return jresult;
44605 }
44606
44607
44608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44609   void * jresult ;
44610   Dali::PathConstrainer::Property *result = 0 ;
44611
44612   {
44613     try {
44614       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44615     } catch (std::out_of_range& e) {
44616       {
44617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44618       };
44619     } catch (std::exception& e) {
44620       {
44621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44622       };
44623     } catch (Dali::DaliException e) {
44624       {
44625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44626       };
44627     } catch (...) {
44628       {
44629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44630       };
44631     }
44632   }
44633
44634   jresult = (void *)result;
44635   return jresult;
44636 }
44637
44638
44639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44640   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44641
44642   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44643   {
44644     try {
44645       delete arg1;
44646     } catch (std::out_of_range& e) {
44647       {
44648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44649       };
44650     } catch (std::exception& e) {
44651       {
44652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44653       };
44654     } catch (Dali::DaliException e) {
44655       {
44656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44657       };
44658     } catch (...) {
44659       {
44660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44661       };
44662     }
44663   }
44664
44665 }
44666
44667
44668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44669   void * jresult ;
44670   Dali::PathConstrainer result;
44671
44672   {
44673     try {
44674       result = Dali::PathConstrainer::New();
44675     } catch (std::out_of_range& e) {
44676       {
44677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44678       };
44679     } catch (std::exception& e) {
44680       {
44681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44682       };
44683     } catch (Dali::DaliException e) {
44684       {
44685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44686       };
44687     } catch (...) {
44688       {
44689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44690       };
44691     }
44692   }
44693
44694   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44695   return jresult;
44696 }
44697
44698
44699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44700   void * jresult ;
44701   Dali::BaseHandle arg1 ;
44702   Dali::BaseHandle *argp1 ;
44703   Dali::PathConstrainer result;
44704
44705   argp1 = (Dali::BaseHandle *)jarg1;
44706   if (!argp1) {
44707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44708     return 0;
44709   }
44710   arg1 = *argp1;
44711   {
44712     try {
44713       result = Dali::PathConstrainer::DownCast(arg1);
44714     } catch (std::out_of_range& e) {
44715       {
44716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44717       };
44718     } catch (std::exception& e) {
44719       {
44720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44721       };
44722     } catch (Dali::DaliException e) {
44723       {
44724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44725       };
44726     } catch (...) {
44727       {
44728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44729       };
44730     }
44731   }
44732
44733   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44734   return jresult;
44735 }
44736
44737
44738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44739   void * jresult ;
44740   Dali::PathConstrainer *result = 0 ;
44741
44742   {
44743     try {
44744       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44745     } catch (std::out_of_range& e) {
44746       {
44747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44748       };
44749     } catch (std::exception& e) {
44750       {
44751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44752       };
44753     } catch (Dali::DaliException e) {
44754       {
44755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44756       };
44757     } catch (...) {
44758       {
44759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44760       };
44761     }
44762   }
44763
44764   jresult = (void *)result;
44765   return jresult;
44766 }
44767
44768
44769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44770   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44771
44772   arg1 = (Dali::PathConstrainer *)jarg1;
44773   {
44774     try {
44775       delete arg1;
44776     } catch (std::out_of_range& e) {
44777       {
44778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44779       };
44780     } catch (std::exception& e) {
44781       {
44782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44783       };
44784     } catch (Dali::DaliException e) {
44785       {
44786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44787       };
44788     } catch (...) {
44789       {
44790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44791       };
44792     }
44793   }
44794
44795 }
44796
44797
44798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44799   void * jresult ;
44800   Dali::PathConstrainer *arg1 = 0 ;
44801   Dali::PathConstrainer *result = 0 ;
44802
44803   arg1 = (Dali::PathConstrainer *)jarg1;
44804   if (!arg1) {
44805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44806     return 0;
44807   }
44808   {
44809     try {
44810       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44811     } catch (std::out_of_range& e) {
44812       {
44813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44814       };
44815     } catch (std::exception& e) {
44816       {
44817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44818       };
44819     } catch (Dali::DaliException e) {
44820       {
44821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44822       };
44823     } catch (...) {
44824       {
44825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44826       };
44827     }
44828   }
44829
44830   jresult = (void *)result;
44831   return jresult;
44832 }
44833
44834
44835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44836   void * jresult ;
44837   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44838   Dali::PathConstrainer *arg2 = 0 ;
44839   Dali::PathConstrainer *result = 0 ;
44840
44841   arg1 = (Dali::PathConstrainer *)jarg1;
44842   arg2 = (Dali::PathConstrainer *)jarg2;
44843   if (!arg2) {
44844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44845     return 0;
44846   }
44847   {
44848     try {
44849       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44850     } catch (std::out_of_range& e) {
44851       {
44852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44853       };
44854     } catch (std::exception& e) {
44855       {
44856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44857       };
44858     } catch (Dali::DaliException e) {
44859       {
44860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44861       };
44862     } catch (...) {
44863       {
44864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44865       };
44866     }
44867   }
44868
44869   jresult = (void *)result;
44870   return jresult;
44871 }
44872
44873
44874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44875   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44876   SwigValueWrapper< Dali::Property > arg2 ;
44877   SwigValueWrapper< Dali::Property > arg3 ;
44878   Dali::Vector2 *arg4 = 0 ;
44879   Dali::Vector2 *arg5 = 0 ;
44880   Dali::Property *argp2 ;
44881   Dali::Property *argp3 ;
44882
44883   arg1 = (Dali::PathConstrainer *)jarg1;
44884   argp2 = (Dali::Property *)jarg2;
44885   if (!argp2) {
44886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44887     return ;
44888   }
44889   arg2 = *argp2;
44890   argp3 = (Dali::Property *)jarg3;
44891   if (!argp3) {
44892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44893     return ;
44894   }
44895   arg3 = *argp3;
44896   arg4 = (Dali::Vector2 *)jarg4;
44897   if (!arg4) {
44898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44899     return ;
44900   }
44901   arg5 = (Dali::Vector2 *)jarg5;
44902   if (!arg5) {
44903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44904     return ;
44905   }
44906   {
44907     try {
44908       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44909     } catch (std::out_of_range& e) {
44910       {
44911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44912       };
44913     } catch (std::exception& e) {
44914       {
44915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44916       };
44917     } catch (Dali::DaliException e) {
44918       {
44919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44920       };
44921     } catch (...) {
44922       {
44923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44924       };
44925     }
44926   }
44927
44928 }
44929
44930
44931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44932   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44933   SwigValueWrapper< Dali::Property > arg2 ;
44934   SwigValueWrapper< Dali::Property > arg3 ;
44935   Dali::Vector2 *arg4 = 0 ;
44936   Dali::Property *argp2 ;
44937   Dali::Property *argp3 ;
44938
44939   arg1 = (Dali::PathConstrainer *)jarg1;
44940   argp2 = (Dali::Property *)jarg2;
44941   if (!argp2) {
44942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44943     return ;
44944   }
44945   arg2 = *argp2;
44946   argp3 = (Dali::Property *)jarg3;
44947   if (!argp3) {
44948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44949     return ;
44950   }
44951   arg3 = *argp3;
44952   arg4 = (Dali::Vector2 *)jarg4;
44953   if (!arg4) {
44954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44955     return ;
44956   }
44957   {
44958     try {
44959       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44960     } catch (std::out_of_range& e) {
44961       {
44962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44963       };
44964     } catch (std::exception& e) {
44965       {
44966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44967       };
44968     } catch (Dali::DaliException e) {
44969       {
44970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44971       };
44972     } catch (...) {
44973       {
44974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44975       };
44976     }
44977   }
44978
44979 }
44980
44981
44982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44983   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44984   Dali::Handle *arg2 = 0 ;
44985
44986   arg1 = (Dali::PathConstrainer *)jarg1;
44987   arg2 = (Dali::Handle *)jarg2;
44988   if (!arg2) {
44989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44990     return ;
44991   }
44992   {
44993     try {
44994       (arg1)->Remove(*arg2);
44995     } catch (std::out_of_range& e) {
44996       {
44997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44998       };
44999     } catch (std::exception& e) {
45000       {
45001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45002       };
45003     } catch (Dali::DaliException e) {
45004       {
45005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45006       };
45007     } catch (...) {
45008       {
45009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45010       };
45011     }
45012   }
45013
45014 }
45015
45016
45017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45018   int jresult ;
45019   Dali::FittingMode::Type result;
45020
45021   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45022   jresult = (int)result;
45023   return jresult;
45024 }
45025
45026
45027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45028   int jresult ;
45029   Dali::SamplingMode::Type result;
45030
45031   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45032   jresult = (int)result;
45033   return jresult;
45034 }
45035
45036
45037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45038   void * jresult ;
45039   Dali::BufferImage *result = 0 ;
45040
45041   {
45042     try {
45043       result = (Dali::BufferImage *)new Dali::BufferImage();
45044     } catch (std::out_of_range& e) {
45045       {
45046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45047       };
45048     } catch (std::exception& e) {
45049       {
45050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45051       };
45052     } catch (Dali::DaliException e) {
45053       {
45054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45055       };
45056     } catch (...) {
45057       {
45058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45059       };
45060     }
45061   }
45062
45063   jresult = (void *)result;
45064   return jresult;
45065 }
45066
45067
45068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45069   void * jresult ;
45070   unsigned int arg1 ;
45071   unsigned int arg2 ;
45072   Dali::Pixel::Format arg3 ;
45073   Dali::BufferImage result;
45074
45075   arg1 = (unsigned int)jarg1;
45076   arg2 = (unsigned int)jarg2;
45077   arg3 = (Dali::Pixel::Format)jarg3;
45078   {
45079     try {
45080       result = Dali::BufferImage::New(arg1,arg2,arg3);
45081     } catch (std::out_of_range& e) {
45082       {
45083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45084       };
45085     } catch (std::exception& e) {
45086       {
45087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45088       };
45089     } catch (Dali::DaliException e) {
45090       {
45091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45092       };
45093     } catch (...) {
45094       {
45095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45096       };
45097     }
45098   }
45099
45100   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45101   return jresult;
45102 }
45103
45104
45105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45106   void * jresult ;
45107   unsigned int arg1 ;
45108   unsigned int arg2 ;
45109   Dali::BufferImage result;
45110
45111   arg1 = (unsigned int)jarg1;
45112   arg2 = (unsigned int)jarg2;
45113   {
45114     try {
45115       result = Dali::BufferImage::New(arg1,arg2);
45116     } catch (std::out_of_range& e) {
45117       {
45118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45119       };
45120     } catch (std::exception& e) {
45121       {
45122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45123       };
45124     } catch (Dali::DaliException e) {
45125       {
45126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45127       };
45128     } catch (...) {
45129       {
45130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45131       };
45132     }
45133   }
45134
45135   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45136   return jresult;
45137 }
45138
45139
45140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45141   void * jresult ;
45142   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45143   unsigned int arg2 ;
45144   unsigned int arg3 ;
45145   Dali::Pixel::Format arg4 ;
45146   unsigned int arg5 ;
45147   Dali::BufferImage result;
45148
45149   arg1 = jarg1;
45150   arg2 = (unsigned int)jarg2;
45151   arg3 = (unsigned int)jarg3;
45152   arg4 = (Dali::Pixel::Format)jarg4;
45153   arg5 = (unsigned int)jarg5;
45154   {
45155     try {
45156       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45157     } catch (std::out_of_range& e) {
45158       {
45159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45160       };
45161     } catch (std::exception& e) {
45162       {
45163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45164       };
45165     } catch (Dali::DaliException e) {
45166       {
45167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45168       };
45169     } catch (...) {
45170       {
45171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45172       };
45173     }
45174   }
45175
45176   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45177
45178
45179   return jresult;
45180 }
45181
45182
45183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45184   void * jresult ;
45185   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45186   unsigned int arg2 ;
45187   unsigned int arg3 ;
45188   Dali::Pixel::Format arg4 ;
45189   Dali::BufferImage result;
45190
45191   arg1 = jarg1;
45192   arg2 = (unsigned int)jarg2;
45193   arg3 = (unsigned int)jarg3;
45194   arg4 = (Dali::Pixel::Format)jarg4;
45195   {
45196     try {
45197       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45198     } catch (std::out_of_range& e) {
45199       {
45200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45201       };
45202     } catch (std::exception& e) {
45203       {
45204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45205       };
45206     } catch (Dali::DaliException e) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45209       };
45210     } catch (...) {
45211       {
45212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45213       };
45214     }
45215   }
45216
45217   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45218
45219
45220   return jresult;
45221 }
45222
45223
45224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45225   void * jresult ;
45226   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45227   unsigned int arg2 ;
45228   unsigned int arg3 ;
45229   Dali::BufferImage result;
45230
45231   arg1 = jarg1;
45232   arg2 = (unsigned int)jarg2;
45233   arg3 = (unsigned int)jarg3;
45234   {
45235     try {
45236       result = Dali::BufferImage::New(arg1,arg2,arg3);
45237     } catch (std::out_of_range& e) {
45238       {
45239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45240       };
45241     } catch (std::exception& e) {
45242       {
45243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45244       };
45245     } catch (Dali::DaliException e) {
45246       {
45247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45248       };
45249     } catch (...) {
45250       {
45251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45252       };
45253     }
45254   }
45255
45256   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45257
45258
45259   return jresult;
45260 }
45261
45262
45263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45264   void * jresult ;
45265   Dali::BaseHandle arg1 ;
45266   Dali::BaseHandle *argp1 ;
45267   Dali::BufferImage result;
45268
45269   argp1 = (Dali::BaseHandle *)jarg1;
45270   if (!argp1) {
45271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45272     return 0;
45273   }
45274   arg1 = *argp1;
45275   {
45276     try {
45277       result = Dali::BufferImage::DownCast(arg1);
45278     } catch (std::out_of_range& e) {
45279       {
45280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45281       };
45282     } catch (std::exception& e) {
45283       {
45284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45285       };
45286     } catch (Dali::DaliException e) {
45287       {
45288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45289       };
45290     } catch (...) {
45291       {
45292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45293       };
45294     }
45295   }
45296
45297   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45298   return jresult;
45299 }
45300
45301
45302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45303   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45304
45305   arg1 = (Dali::BufferImage *)jarg1;
45306   {
45307     try {
45308       delete arg1;
45309     } catch (std::out_of_range& e) {
45310       {
45311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45312       };
45313     } catch (std::exception& e) {
45314       {
45315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45316       };
45317     } catch (Dali::DaliException e) {
45318       {
45319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45320       };
45321     } catch (...) {
45322       {
45323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45324       };
45325     }
45326   }
45327
45328 }
45329
45330
45331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45332   void * jresult ;
45333   Dali::BufferImage *arg1 = 0 ;
45334   Dali::BufferImage *result = 0 ;
45335
45336   arg1 = (Dali::BufferImage *)jarg1;
45337   if (!arg1) {
45338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45339     return 0;
45340   }
45341   {
45342     try {
45343       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45344     } catch (std::out_of_range& e) {
45345       {
45346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45347       };
45348     } catch (std::exception& e) {
45349       {
45350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45351       };
45352     } catch (Dali::DaliException e) {
45353       {
45354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45355       };
45356     } catch (...) {
45357       {
45358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45359       };
45360     }
45361   }
45362
45363   jresult = (void *)result;
45364   return jresult;
45365 }
45366
45367
45368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45369   void * jresult ;
45370   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45371   Dali::BufferImage *arg2 = 0 ;
45372   Dali::BufferImage *result = 0 ;
45373
45374   arg1 = (Dali::BufferImage *)jarg1;
45375   arg2 = (Dali::BufferImage *)jarg2;
45376   if (!arg2) {
45377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45378     return 0;
45379   }
45380   {
45381     try {
45382       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45383     } catch (std::out_of_range& e) {
45384       {
45385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45386       };
45387     } catch (std::exception& e) {
45388       {
45389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45390       };
45391     } catch (Dali::DaliException e) {
45392       {
45393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45394       };
45395     } catch (...) {
45396       {
45397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45398       };
45399     }
45400   }
45401
45402   jresult = (void *)result;
45403   return jresult;
45404 }
45405
45406
45407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45408   void * jresult ;
45409   Dali::BufferImage result;
45410
45411   {
45412     try {
45413       result = Dali::BufferImage::WHITE();
45414     } catch (std::out_of_range& e) {
45415       {
45416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45417       };
45418     } catch (std::exception& e) {
45419       {
45420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45421       };
45422     } catch (Dali::DaliException e) {
45423       {
45424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45425       };
45426     } catch (...) {
45427       {
45428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45429       };
45430     }
45431   }
45432
45433   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45434   return jresult;
45435 }
45436
45437
45438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45439   void * jresult ;
45440   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45441   Dali::PixelBuffer *result = 0 ;
45442
45443   arg1 = (Dali::BufferImage *)jarg1;
45444   {
45445     try {
45446       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45447     } catch (std::out_of_range& e) {
45448       {
45449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45450       };
45451     } catch (std::exception& e) {
45452       {
45453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45454       };
45455     } catch (Dali::DaliException e) {
45456       {
45457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45458       };
45459     } catch (...) {
45460       {
45461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45462       };
45463     }
45464   }
45465
45466   jresult = (void *)result;
45467   return jresult;
45468 }
45469
45470
45471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45472   unsigned int jresult ;
45473   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45474   unsigned int result;
45475
45476   arg1 = (Dali::BufferImage *)jarg1;
45477   {
45478     try {
45479       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45480     } catch (std::out_of_range& e) {
45481       {
45482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45483       };
45484     } catch (std::exception& e) {
45485       {
45486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45487       };
45488     } catch (Dali::DaliException e) {
45489       {
45490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45491       };
45492     } catch (...) {
45493       {
45494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45495       };
45496     }
45497   }
45498
45499   jresult = result;
45500   return jresult;
45501 }
45502
45503
45504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45505   unsigned int jresult ;
45506   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45507   unsigned int result;
45508
45509   arg1 = (Dali::BufferImage *)jarg1;
45510   {
45511     try {
45512       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45513     } catch (std::out_of_range& e) {
45514       {
45515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45516       };
45517     } catch (std::exception& e) {
45518       {
45519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45520       };
45521     } catch (Dali::DaliException e) {
45522       {
45523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45524       };
45525     } catch (...) {
45526       {
45527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45528       };
45529     }
45530   }
45531
45532   jresult = result;
45533   return jresult;
45534 }
45535
45536
45537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45538   int jresult ;
45539   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45540   Dali::Pixel::Format result;
45541
45542   arg1 = (Dali::BufferImage *)jarg1;
45543   {
45544     try {
45545       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45546     } catch (std::out_of_range& e) {
45547       {
45548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45549       };
45550     } catch (std::exception& e) {
45551       {
45552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45553       };
45554     } catch (Dali::DaliException e) {
45555       {
45556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45557       };
45558     } catch (...) {
45559       {
45560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45561       };
45562     }
45563   }
45564
45565   jresult = (int)result;
45566   return jresult;
45567 }
45568
45569
45570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45571   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45572
45573   arg1 = (Dali::BufferImage *)jarg1;
45574   {
45575     try {
45576       (arg1)->Update();
45577     } catch (std::out_of_range& e) {
45578       {
45579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45580       };
45581     } catch (std::exception& e) {
45582       {
45583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45584       };
45585     } catch (Dali::DaliException e) {
45586       {
45587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45588       };
45589     } catch (...) {
45590       {
45591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45592       };
45593     }
45594   }
45595
45596 }
45597
45598
45599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45600   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45601   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45602   Dali::RectArea *argp2 ;
45603
45604   arg1 = (Dali::BufferImage *)jarg1;
45605   argp2 = (Dali::RectArea *)jarg2;
45606   if (!argp2) {
45607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45608     return ;
45609   }
45610   arg2 = *argp2;
45611   {
45612     try {
45613       (arg1)->Update(arg2);
45614     } catch (std::out_of_range& e) {
45615       {
45616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45617       };
45618     } catch (std::exception& e) {
45619       {
45620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45621       };
45622     } catch (Dali::DaliException e) {
45623       {
45624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45625       };
45626     } catch (...) {
45627       {
45628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45629       };
45630     }
45631   }
45632
45633 }
45634
45635
45636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45637   unsigned int jresult ;
45638   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45639   bool result;
45640
45641   arg1 = (Dali::BufferImage *)jarg1;
45642   {
45643     try {
45644       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45645     } catch (std::out_of_range& e) {
45646       {
45647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45648       };
45649     } catch (std::exception& e) {
45650       {
45651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45652       };
45653     } catch (Dali::DaliException e) {
45654       {
45655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45656       };
45657     } catch (...) {
45658       {
45659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45660       };
45661     }
45662   }
45663
45664   jresult = result;
45665   return jresult;
45666 }
45667
45668
45669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45670   void * jresult ;
45671   Dali::EncodedBufferImage *result = 0 ;
45672
45673   {
45674     try {
45675       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45676     } catch (std::out_of_range& e) {
45677       {
45678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45679       };
45680     } catch (std::exception& e) {
45681       {
45682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45683       };
45684     } catch (Dali::DaliException e) {
45685       {
45686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45687       };
45688     } catch (...) {
45689       {
45690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45691       };
45692     }
45693   }
45694
45695   jresult = (void *)result;
45696   return jresult;
45697 }
45698
45699
45700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45701   void * jresult ;
45702   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45703   std::size_t arg2 ;
45704   Dali::EncodedBufferImage result;
45705
45706   arg1 = (uint8_t *)jarg1;
45707   arg2 = (std::size_t)jarg2;
45708   {
45709     try {
45710       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45711     } catch (std::out_of_range& e) {
45712       {
45713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45714       };
45715     } catch (std::exception& e) {
45716       {
45717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45718       };
45719     } catch (Dali::DaliException e) {
45720       {
45721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45722       };
45723     } catch (...) {
45724       {
45725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45726       };
45727     }
45728   }
45729
45730   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45731   return jresult;
45732 }
45733
45734
45735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45736   void * jresult ;
45737   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45738   std::size_t arg2 ;
45739   Dali::ImageDimensions arg3 ;
45740   Dali::FittingMode::Type arg4 ;
45741   Dali::SamplingMode::Type arg5 ;
45742   bool arg6 ;
45743   Dali::ImageDimensions *argp3 ;
45744   Dali::EncodedBufferImage result;
45745
45746   arg1 = (uint8_t *)jarg1;
45747   arg2 = (std::size_t)jarg2;
45748   argp3 = (Dali::ImageDimensions *)jarg3;
45749   if (!argp3) {
45750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45751     return 0;
45752   }
45753   arg3 = *argp3;
45754   arg4 = (Dali::FittingMode::Type)jarg4;
45755   arg5 = (Dali::SamplingMode::Type)jarg5;
45756   arg6 = jarg6 ? true : false;
45757   {
45758     try {
45759       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45760     } catch (std::out_of_range& e) {
45761       {
45762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45763       };
45764     } catch (std::exception& e) {
45765       {
45766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45767       };
45768     } catch (Dali::DaliException e) {
45769       {
45770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45771       };
45772     } catch (...) {
45773       {
45774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45775       };
45776     }
45777   }
45778
45779   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45780   return jresult;
45781 }
45782
45783
45784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45785   void * jresult ;
45786   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45787   std::size_t arg2 ;
45788   Dali::ImageDimensions arg3 ;
45789   Dali::FittingMode::Type arg4 ;
45790   Dali::SamplingMode::Type arg5 ;
45791   Dali::ImageDimensions *argp3 ;
45792   Dali::EncodedBufferImage result;
45793
45794   arg1 = (uint8_t *)jarg1;
45795   arg2 = (std::size_t)jarg2;
45796   argp3 = (Dali::ImageDimensions *)jarg3;
45797   if (!argp3) {
45798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45799     return 0;
45800   }
45801   arg3 = *argp3;
45802   arg4 = (Dali::FittingMode::Type)jarg4;
45803   arg5 = (Dali::SamplingMode::Type)jarg5;
45804   {
45805     try {
45806       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45807     } catch (std::out_of_range& e) {
45808       {
45809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45810       };
45811     } catch (std::exception& e) {
45812       {
45813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45814       };
45815     } catch (Dali::DaliException e) {
45816       {
45817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45818       };
45819     } catch (...) {
45820       {
45821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45822       };
45823     }
45824   }
45825
45826   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45827   return jresult;
45828 }
45829
45830
45831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45832   void * jresult ;
45833   Dali::BaseHandle arg1 ;
45834   Dali::BaseHandle *argp1 ;
45835   Dali::EncodedBufferImage result;
45836
45837   argp1 = (Dali::BaseHandle *)jarg1;
45838   if (!argp1) {
45839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45840     return 0;
45841   }
45842   arg1 = *argp1;
45843   {
45844     try {
45845       result = Dali::EncodedBufferImage::DownCast(arg1);
45846     } catch (std::out_of_range& e) {
45847       {
45848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45849       };
45850     } catch (std::exception& e) {
45851       {
45852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45853       };
45854     } catch (Dali::DaliException e) {
45855       {
45856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45857       };
45858     } catch (...) {
45859       {
45860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45861       };
45862     }
45863   }
45864
45865   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45866   return jresult;
45867 }
45868
45869
45870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45871   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45872
45873   arg1 = (Dali::EncodedBufferImage *)jarg1;
45874   {
45875     try {
45876       delete arg1;
45877     } catch (std::out_of_range& e) {
45878       {
45879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45880       };
45881     } catch (std::exception& e) {
45882       {
45883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45884       };
45885     } catch (Dali::DaliException e) {
45886       {
45887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45888       };
45889     } catch (...) {
45890       {
45891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45892       };
45893     }
45894   }
45895
45896 }
45897
45898
45899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45900   void * jresult ;
45901   Dali::EncodedBufferImage *arg1 = 0 ;
45902   Dali::EncodedBufferImage *result = 0 ;
45903
45904   arg1 = (Dali::EncodedBufferImage *)jarg1;
45905   if (!arg1) {
45906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45907     return 0;
45908   }
45909   {
45910     try {
45911       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45912     } catch (std::out_of_range& e) {
45913       {
45914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45915       };
45916     } catch (std::exception& e) {
45917       {
45918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45919       };
45920     } catch (Dali::DaliException e) {
45921       {
45922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45923       };
45924     } catch (...) {
45925       {
45926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45927       };
45928     }
45929   }
45930
45931   jresult = (void *)result;
45932   return jresult;
45933 }
45934
45935
45936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45937   void * jresult ;
45938   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45939   Dali::EncodedBufferImage *arg2 = 0 ;
45940   Dali::EncodedBufferImage *result = 0 ;
45941
45942   arg1 = (Dali::EncodedBufferImage *)jarg1;
45943   arg2 = (Dali::EncodedBufferImage *)jarg2;
45944   if (!arg2) {
45945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45946     return 0;
45947   }
45948   {
45949     try {
45950       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45951     } catch (std::out_of_range& e) {
45952       {
45953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45954       };
45955     } catch (std::exception& e) {
45956       {
45957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45958       };
45959     } catch (Dali::DaliException e) {
45960       {
45961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45962       };
45963     } catch (...) {
45964       {
45965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45966       };
45967     }
45968   }
45969
45970   jresult = (void *)result;
45971   return jresult;
45972 }
45973
45974
45975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45976   void * jresult ;
45977   Dali::NativeImage *result = 0 ;
45978
45979   {
45980     try {
45981       result = (Dali::NativeImage *)new Dali::NativeImage();
45982     } catch (std::out_of_range& e) {
45983       {
45984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45985       };
45986     } catch (std::exception& e) {
45987       {
45988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45989       };
45990     } catch (Dali::DaliException e) {
45991       {
45992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45993       };
45994     } catch (...) {
45995       {
45996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45997       };
45998     }
45999   }
46000
46001   jresult = (void *)result;
46002   return jresult;
46003 }
46004
46005
46006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46007   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46008
46009   arg1 = (Dali::NativeImage *)jarg1;
46010   {
46011     try {
46012       delete arg1;
46013     } catch (std::out_of_range& e) {
46014       {
46015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46016       };
46017     } catch (std::exception& e) {
46018       {
46019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46020       };
46021     } catch (Dali::DaliException e) {
46022       {
46023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46024       };
46025     } catch (...) {
46026       {
46027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46028       };
46029     }
46030   }
46031
46032 }
46033
46034
46035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46036   void * jresult ;
46037   Dali::NativeImage *arg1 = 0 ;
46038   Dali::NativeImage *result = 0 ;
46039
46040   arg1 = (Dali::NativeImage *)jarg1;
46041   if (!arg1) {
46042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46043     return 0;
46044   }
46045   {
46046     try {
46047       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46048     } catch (std::out_of_range& e) {
46049       {
46050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46051       };
46052     } catch (std::exception& e) {
46053       {
46054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46055       };
46056     } catch (Dali::DaliException e) {
46057       {
46058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46059       };
46060     } catch (...) {
46061       {
46062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46063       };
46064     }
46065   }
46066
46067   jresult = (void *)result;
46068   return jresult;
46069 }
46070
46071
46072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46073   void * jresult ;
46074   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46075   Dali::NativeImage *arg2 = 0 ;
46076   Dali::NativeImage *result = 0 ;
46077
46078   arg1 = (Dali::NativeImage *)jarg1;
46079   arg2 = (Dali::NativeImage *)jarg2;
46080   if (!arg2) {
46081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46082     return 0;
46083   }
46084   {
46085     try {
46086       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46087     } catch (std::out_of_range& e) {
46088       {
46089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46090       };
46091     } catch (std::exception& e) {
46092       {
46093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46094       };
46095     } catch (Dali::DaliException e) {
46096       {
46097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46098       };
46099     } catch (...) {
46100       {
46101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46102       };
46103     }
46104   }
46105
46106   jresult = (void *)result;
46107   return jresult;
46108 }
46109
46110
46111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46112   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46113
46114   arg1 = (Dali::NativeImage *)jarg1;
46115   {
46116     try {
46117       (arg1)->CreateGlTexture();
46118     } catch (std::out_of_range& e) {
46119       {
46120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46121       };
46122     } catch (std::exception& e) {
46123       {
46124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46125       };
46126     } catch (Dali::DaliException e) {
46127       {
46128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46129       };
46130     } catch (...) {
46131       {
46132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46133       };
46134     }
46135   }
46136
46137 }
46138
46139
46140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46141   void * jresult ;
46142   NativeImageInterface *arg1 = 0 ;
46143   Dali::NativeImage result;
46144
46145   arg1 = (NativeImageInterface *)jarg1;
46146   if (!arg1) {
46147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46148     return 0;
46149   }
46150   {
46151     try {
46152       result = Dali::NativeImage::New(*arg1);
46153     } catch (std::out_of_range& e) {
46154       {
46155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46156       };
46157     } catch (std::exception& e) {
46158       {
46159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46160       };
46161     } catch (Dali::DaliException e) {
46162       {
46163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46164       };
46165     } catch (...) {
46166       {
46167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46168       };
46169     }
46170   }
46171
46172   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46173   return jresult;
46174 }
46175
46176
46177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46178   void * jresult ;
46179   Dali::BaseHandle arg1 ;
46180   Dali::BaseHandle *argp1 ;
46181   Dali::NativeImage result;
46182
46183   argp1 = (Dali::BaseHandle *)jarg1;
46184   if (!argp1) {
46185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46186     return 0;
46187   }
46188   arg1 = *argp1;
46189   {
46190     try {
46191       result = Dali::NativeImage::DownCast(arg1);
46192     } catch (std::out_of_range& e) {
46193       {
46194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46195       };
46196     } catch (std::exception& e) {
46197       {
46198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46199       };
46200     } catch (Dali::DaliException e) {
46201       {
46202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46203       };
46204     } catch (...) {
46205       {
46206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46207       };
46208     }
46209   }
46210
46211   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46212   return jresult;
46213 }
46214
46215
46216 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46217   char * jresult ;
46218   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46219   char *result = 0 ;
46220
46221   arg1 = (Dali::NativeImage *)jarg1;
46222   {
46223     try {
46224       result = (char *)(arg1)->GetCustomFragmentPreFix();
46225     } catch (std::out_of_range& e) {
46226       {
46227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46228       };
46229     } catch (std::exception& e) {
46230       {
46231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46232       };
46233     } catch (Dali::DaliException e) {
46234       {
46235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46236       };
46237     } catch (...) {
46238       {
46239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46240       };
46241     }
46242   }
46243
46244   jresult = SWIG_csharp_string_callback((const char *)result);
46245   return jresult;
46246 }
46247
46248
46249 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46250   char * jresult ;
46251   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46252   char *result = 0 ;
46253
46254   arg1 = (Dali::NativeImage *)jarg1;
46255   {
46256     try {
46257       result = (char *)(arg1)->GetCustomSamplerTypename();
46258     } catch (std::out_of_range& e) {
46259       {
46260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46261       };
46262     } catch (std::exception& e) {
46263       {
46264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46265       };
46266     } catch (Dali::DaliException e) {
46267       {
46268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46269       };
46270     } catch (...) {
46271       {
46272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46273       };
46274     }
46275   }
46276
46277   jresult = SWIG_csharp_string_callback((const char *)result);
46278   return jresult;
46279 }
46280
46281
46282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46283   unsigned int jresult ;
46284   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46285   bool result;
46286
46287   arg1 = (Dali::NativeImageInterface *)jarg1;
46288   {
46289     try {
46290       result = (bool)(arg1)->GlExtensionCreate();
46291     } catch (std::out_of_range& e) {
46292       {
46293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46294       };
46295     } catch (std::exception& e) {
46296       {
46297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46298       };
46299     } catch (Dali::DaliException e) {
46300       {
46301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46302       };
46303     } catch (...) {
46304       {
46305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46306       };
46307     }
46308   }
46309
46310   jresult = result;
46311   return jresult;
46312 }
46313
46314
46315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46316   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46317
46318   arg1 = (Dali::NativeImageInterface *)jarg1;
46319   {
46320     try {
46321       (arg1)->GlExtensionDestroy();
46322     } catch (std::out_of_range& e) {
46323       {
46324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46325       };
46326     } catch (std::exception& e) {
46327       {
46328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46329       };
46330     } catch (Dali::DaliException e) {
46331       {
46332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46333       };
46334     } catch (...) {
46335       {
46336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46337       };
46338     }
46339   }
46340
46341 }
46342
46343
46344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46345   unsigned int jresult ;
46346   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46347   unsigned int result;
46348
46349   arg1 = (Dali::NativeImageInterface *)jarg1;
46350   {
46351     try {
46352       result = (unsigned int)(arg1)->TargetTexture();
46353     } catch (std::out_of_range& e) {
46354       {
46355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46356       };
46357     } catch (std::exception& e) {
46358       {
46359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46360       };
46361     } catch (Dali::DaliException e) {
46362       {
46363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46364       };
46365     } catch (...) {
46366       {
46367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46368       };
46369     }
46370   }
46371
46372   jresult = result;
46373   return jresult;
46374 }
46375
46376
46377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46378   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46379
46380   arg1 = (Dali::NativeImageInterface *)jarg1;
46381   {
46382     try {
46383       (arg1)->PrepareTexture();
46384     } catch (std::out_of_range& e) {
46385       {
46386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46387       };
46388     } catch (std::exception& e) {
46389       {
46390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46391       };
46392     } catch (Dali::DaliException e) {
46393       {
46394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46395       };
46396     } catch (...) {
46397       {
46398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46399       };
46400     }
46401   }
46402
46403 }
46404
46405
46406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46407   unsigned int jresult ;
46408   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46409   unsigned int result;
46410
46411   arg1 = (Dali::NativeImageInterface *)jarg1;
46412   {
46413     try {
46414       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46415     } catch (std::out_of_range& e) {
46416       {
46417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46418       };
46419     } catch (std::exception& e) {
46420       {
46421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46422       };
46423     } catch (Dali::DaliException e) {
46424       {
46425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46426       };
46427     } catch (...) {
46428       {
46429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46430       };
46431     }
46432   }
46433
46434   jresult = result;
46435   return jresult;
46436 }
46437
46438
46439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46440   unsigned int jresult ;
46441   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46442   unsigned int result;
46443
46444   arg1 = (Dali::NativeImageInterface *)jarg1;
46445   {
46446     try {
46447       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46448     } catch (std::out_of_range& e) {
46449       {
46450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46451       };
46452     } catch (std::exception& e) {
46453       {
46454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46455       };
46456     } catch (Dali::DaliException e) {
46457       {
46458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46459       };
46460     } catch (...) {
46461       {
46462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46463       };
46464     }
46465   }
46466
46467   jresult = result;
46468   return jresult;
46469 }
46470
46471
46472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46473   unsigned int jresult ;
46474   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46475   bool result;
46476
46477   arg1 = (Dali::NativeImageInterface *)jarg1;
46478   {
46479     try {
46480       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46481     } catch (std::out_of_range& e) {
46482       {
46483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46484       };
46485     } catch (std::exception& e) {
46486       {
46487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46488       };
46489     } catch (Dali::DaliException e) {
46490       {
46491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46492       };
46493     } catch (...) {
46494       {
46495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46496       };
46497     }
46498   }
46499
46500   jresult = result;
46501   return jresult;
46502 }
46503
46504
46505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46506   void * jresult ;
46507   std::string *arg1 = 0 ;
46508   Dali::ImageDimensions result;
46509
46510   if (!jarg1) {
46511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46512     return 0;
46513   }
46514   std::string arg1_str(jarg1);
46515   arg1 = &arg1_str;
46516   {
46517     try {
46518       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46519     } catch (std::out_of_range& e) {
46520       {
46521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46522       };
46523     } catch (std::exception& e) {
46524       {
46525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46526       };
46527     } catch (Dali::DaliException e) {
46528       {
46529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46530       };
46531     } catch (...) {
46532       {
46533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46534       };
46535     }
46536   }
46537
46538   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46539
46540   //argout typemap for const std::string&
46541
46542   return jresult;
46543 }
46544
46545
46546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46547   void * jresult ;
46548   Dali::ResourceImage *result = 0 ;
46549
46550   {
46551     try {
46552       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46553     } catch (std::out_of_range& e) {
46554       {
46555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46556       };
46557     } catch (std::exception& e) {
46558       {
46559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46560       };
46561     } catch (Dali::DaliException e) {
46562       {
46563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46564       };
46565     } catch (...) {
46566       {
46567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46568       };
46569     }
46570   }
46571
46572   jresult = (void *)result;
46573   return jresult;
46574 }
46575
46576
46577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46578   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46579
46580   arg1 = (Dali::ResourceImage *)jarg1;
46581   {
46582     try {
46583       delete arg1;
46584     } catch (std::out_of_range& e) {
46585       {
46586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46587       };
46588     } catch (std::exception& e) {
46589       {
46590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46591       };
46592     } catch (Dali::DaliException e) {
46593       {
46594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46595       };
46596     } catch (...) {
46597       {
46598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46599       };
46600     }
46601   }
46602
46603 }
46604
46605
46606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46607   void * jresult ;
46608   Dali::ResourceImage *arg1 = 0 ;
46609   Dali::ResourceImage *result = 0 ;
46610
46611   arg1 = (Dali::ResourceImage *)jarg1;
46612   if (!arg1) {
46613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46614     return 0;
46615   }
46616   {
46617     try {
46618       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46619     } catch (std::out_of_range& e) {
46620       {
46621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46622       };
46623     } catch (std::exception& e) {
46624       {
46625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46626       };
46627     } catch (Dali::DaliException e) {
46628       {
46629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46630       };
46631     } catch (...) {
46632       {
46633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46634       };
46635     }
46636   }
46637
46638   jresult = (void *)result;
46639   return jresult;
46640 }
46641
46642
46643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46644   void * jresult ;
46645   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46646   Dali::ResourceImage *arg2 = 0 ;
46647   Dali::ResourceImage *result = 0 ;
46648
46649   arg1 = (Dali::ResourceImage *)jarg1;
46650   arg2 = (Dali::ResourceImage *)jarg2;
46651   if (!arg2) {
46652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46653     return 0;
46654   }
46655   {
46656     try {
46657       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46658     } catch (std::out_of_range& e) {
46659       {
46660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46661       };
46662     } catch (std::exception& e) {
46663       {
46664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46665       };
46666     } catch (Dali::DaliException e) {
46667       {
46668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46669       };
46670     } catch (...) {
46671       {
46672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46673       };
46674     }
46675   }
46676
46677   jresult = (void *)result;
46678   return jresult;
46679 }
46680
46681
46682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46683   void * jresult ;
46684   std::string *arg1 = 0 ;
46685   bool arg2 ;
46686   Dali::ResourceImage result;
46687
46688   if (!jarg1) {
46689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46690     return 0;
46691   }
46692   std::string arg1_str(jarg1);
46693   arg1 = &arg1_str;
46694   arg2 = jarg2 ? true : false;
46695   {
46696     try {
46697       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46698     } catch (std::out_of_range& e) {
46699       {
46700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46701       };
46702     } catch (std::exception& e) {
46703       {
46704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46705       };
46706     } catch (Dali::DaliException e) {
46707       {
46708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46709       };
46710     } catch (...) {
46711       {
46712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46713       };
46714     }
46715   }
46716
46717   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46718
46719   //argout typemap for const std::string&
46720
46721   return jresult;
46722 }
46723
46724
46725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46726   void * jresult ;
46727   std::string *arg1 = 0 ;
46728   Dali::ResourceImage result;
46729
46730   if (!jarg1) {
46731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46732     return 0;
46733   }
46734   std::string arg1_str(jarg1);
46735   arg1 = &arg1_str;
46736   {
46737     try {
46738       result = Dali::ResourceImage::New((std::string const &)*arg1);
46739     } catch (std::out_of_range& e) {
46740       {
46741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46742       };
46743     } catch (std::exception& e) {
46744       {
46745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46746       };
46747     } catch (Dali::DaliException e) {
46748       {
46749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46750       };
46751     } catch (...) {
46752       {
46753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46754       };
46755     }
46756   }
46757
46758   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46759
46760   //argout typemap for const std::string&
46761
46762   return jresult;
46763 }
46764
46765
46766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46767   void * jresult ;
46768   std::string *arg1 = 0 ;
46769   Dali::ImageDimensions arg2 ;
46770   Dali::FittingMode::Type arg3 ;
46771   Dali::SamplingMode::Type arg4 ;
46772   bool arg5 ;
46773   Dali::ImageDimensions *argp2 ;
46774   Dali::ResourceImage result;
46775
46776   if (!jarg1) {
46777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46778     return 0;
46779   }
46780   std::string arg1_str(jarg1);
46781   arg1 = &arg1_str;
46782   argp2 = (Dali::ImageDimensions *)jarg2;
46783   if (!argp2) {
46784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46785     return 0;
46786   }
46787   arg2 = *argp2;
46788   arg3 = (Dali::FittingMode::Type)jarg3;
46789   arg4 = (Dali::SamplingMode::Type)jarg4;
46790   arg5 = jarg5 ? true : false;
46791   {
46792     try {
46793       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46794     } catch (std::out_of_range& e) {
46795       {
46796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46797       };
46798     } catch (std::exception& e) {
46799       {
46800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46801       };
46802     } catch (Dali::DaliException e) {
46803       {
46804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46805       };
46806     } catch (...) {
46807       {
46808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46809       };
46810     }
46811   }
46812
46813   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46814
46815   //argout typemap for const std::string&
46816
46817   return jresult;
46818 }
46819
46820
46821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46822   void * jresult ;
46823   std::string *arg1 = 0 ;
46824   Dali::ImageDimensions arg2 ;
46825   Dali::FittingMode::Type arg3 ;
46826   Dali::SamplingMode::Type arg4 ;
46827   Dali::ImageDimensions *argp2 ;
46828   Dali::ResourceImage result;
46829
46830   if (!jarg1) {
46831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46832     return 0;
46833   }
46834   std::string arg1_str(jarg1);
46835   arg1 = &arg1_str;
46836   argp2 = (Dali::ImageDimensions *)jarg2;
46837   if (!argp2) {
46838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46839     return 0;
46840   }
46841   arg2 = *argp2;
46842   arg3 = (Dali::FittingMode::Type)jarg3;
46843   arg4 = (Dali::SamplingMode::Type)jarg4;
46844   {
46845     try {
46846       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46847     } catch (std::out_of_range& e) {
46848       {
46849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46850       };
46851     } catch (std::exception& e) {
46852       {
46853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46854       };
46855     } catch (Dali::DaliException e) {
46856       {
46857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46858       };
46859     } catch (...) {
46860       {
46861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46862       };
46863     }
46864   }
46865
46866   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46867
46868   //argout typemap for const std::string&
46869
46870   return jresult;
46871 }
46872
46873
46874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46875   void * jresult ;
46876   std::string *arg1 = 0 ;
46877   Dali::ImageDimensions arg2 ;
46878   Dali::FittingMode::Type arg3 ;
46879   Dali::ImageDimensions *argp2 ;
46880   Dali::ResourceImage result;
46881
46882   if (!jarg1) {
46883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46884     return 0;
46885   }
46886   std::string arg1_str(jarg1);
46887   arg1 = &arg1_str;
46888   argp2 = (Dali::ImageDimensions *)jarg2;
46889   if (!argp2) {
46890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46891     return 0;
46892   }
46893   arg2 = *argp2;
46894   arg3 = (Dali::FittingMode::Type)jarg3;
46895   {
46896     try {
46897       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46898     } catch (std::out_of_range& e) {
46899       {
46900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46901       };
46902     } catch (std::exception& e) {
46903       {
46904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46905       };
46906     } catch (Dali::DaliException e) {
46907       {
46908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46909       };
46910     } catch (...) {
46911       {
46912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46913       };
46914     }
46915   }
46916
46917   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46918
46919   //argout typemap for const std::string&
46920
46921   return jresult;
46922 }
46923
46924
46925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46926   void * jresult ;
46927   std::string *arg1 = 0 ;
46928   Dali::ImageDimensions arg2 ;
46929   Dali::ImageDimensions *argp2 ;
46930   Dali::ResourceImage result;
46931
46932   if (!jarg1) {
46933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46934     return 0;
46935   }
46936   std::string arg1_str(jarg1);
46937   arg1 = &arg1_str;
46938   argp2 = (Dali::ImageDimensions *)jarg2;
46939   if (!argp2) {
46940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46941     return 0;
46942   }
46943   arg2 = *argp2;
46944   {
46945     try {
46946       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46947     } catch (std::out_of_range& e) {
46948       {
46949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46950       };
46951     } catch (std::exception& e) {
46952       {
46953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46954       };
46955     } catch (Dali::DaliException e) {
46956       {
46957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46958       };
46959     } catch (...) {
46960       {
46961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46962       };
46963     }
46964   }
46965
46966   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46967
46968   //argout typemap for const std::string&
46969
46970   return jresult;
46971 }
46972
46973
46974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46975   void * jresult ;
46976   Dali::BaseHandle arg1 ;
46977   Dali::BaseHandle *argp1 ;
46978   Dali::ResourceImage result;
46979
46980   argp1 = (Dali::BaseHandle *)jarg1;
46981   if (!argp1) {
46982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46983     return 0;
46984   }
46985   arg1 = *argp1;
46986   {
46987     try {
46988       result = Dali::ResourceImage::DownCast(arg1);
46989     } catch (std::out_of_range& e) {
46990       {
46991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46992       };
46993     } catch (std::exception& e) {
46994       {
46995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46996       };
46997     } catch (Dali::DaliException e) {
46998       {
46999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47000       };
47001     } catch (...) {
47002       {
47003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47004       };
47005     }
47006   }
47007
47008   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47009   return jresult;
47010 }
47011
47012
47013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47014   int jresult ;
47015   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47016   Dali::LoadingState result;
47017
47018   arg1 = (Dali::ResourceImage *)jarg1;
47019   {
47020     try {
47021       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47022     } catch (std::out_of_range& e) {
47023       {
47024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47025       };
47026     } catch (std::exception& e) {
47027       {
47028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47029       };
47030     } catch (Dali::DaliException e) {
47031       {
47032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47033       };
47034     } catch (...) {
47035       {
47036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47037       };
47038     }
47039   }
47040
47041   jresult = (int)result;
47042   return jresult;
47043 }
47044
47045
47046 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47047   char * jresult ;
47048   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47049   std::string result;
47050
47051   arg1 = (Dali::ResourceImage *)jarg1;
47052   {
47053     try {
47054       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47055     } catch (std::out_of_range& e) {
47056       {
47057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47058       };
47059     } catch (std::exception& e) {
47060       {
47061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47062       };
47063     } catch (Dali::DaliException e) {
47064       {
47065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47066       };
47067     } catch (...) {
47068       {
47069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47070       };
47071     }
47072   }
47073
47074   jresult = SWIG_csharp_string_callback((&result)->c_str());
47075   return jresult;
47076 }
47077
47078
47079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47080   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47081
47082   arg1 = (Dali::ResourceImage *)jarg1;
47083   {
47084     try {
47085       (arg1)->Reload();
47086     } catch (std::out_of_range& e) {
47087       {
47088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47089       };
47090     } catch (std::exception& e) {
47091       {
47092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47093       };
47094     } catch (Dali::DaliException e) {
47095       {
47096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47097       };
47098     } catch (...) {
47099       {
47100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47101       };
47102     }
47103   }
47104
47105 }
47106
47107
47108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47109   void * jresult ;
47110   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47111   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47112
47113   arg1 = (Dali::ResourceImage *)jarg1;
47114   {
47115     try {
47116       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47117     } catch (std::out_of_range& e) {
47118       {
47119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47120       };
47121     } catch (std::exception& e) {
47122       {
47123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47124       };
47125     } catch (Dali::DaliException e) {
47126       {
47127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47128       };
47129     } catch (...) {
47130       {
47131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47132       };
47133     }
47134   }
47135
47136   jresult = (void *)result;
47137   return jresult;
47138 }
47139
47140
47141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47142   void * jresult ;
47143   Dali::FrameBufferImage *result = 0 ;
47144
47145   {
47146     try {
47147       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47148     } catch (std::out_of_range& e) {
47149       {
47150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47151       };
47152     } catch (std::exception& e) {
47153       {
47154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47155       };
47156     } catch (Dali::DaliException e) {
47157       {
47158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47159       };
47160     } catch (...) {
47161       {
47162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47163       };
47164     }
47165   }
47166
47167   jresult = (void *)result;
47168   return jresult;
47169 }
47170
47171
47172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47173   void * jresult ;
47174   unsigned int arg1 ;
47175   unsigned int arg2 ;
47176   Dali::Pixel::Format arg3 ;
47177   Dali::RenderBuffer::Format arg4 ;
47178   Dali::FrameBufferImage result;
47179
47180   arg1 = (unsigned int)jarg1;
47181   arg2 = (unsigned int)jarg2;
47182   arg3 = (Dali::Pixel::Format)jarg3;
47183   arg4 = (Dali::RenderBuffer::Format)jarg4;
47184   {
47185     try {
47186       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47187     } catch (std::out_of_range& e) {
47188       {
47189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47190       };
47191     } catch (std::exception& e) {
47192       {
47193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47194       };
47195     } catch (Dali::DaliException e) {
47196       {
47197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47198       };
47199     } catch (...) {
47200       {
47201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47202       };
47203     }
47204   }
47205
47206   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47207   return jresult;
47208 }
47209
47210
47211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47212   void * jresult ;
47213   unsigned int arg1 ;
47214   unsigned int arg2 ;
47215   Dali::Pixel::Format arg3 ;
47216   Dali::FrameBufferImage result;
47217
47218   arg1 = (unsigned int)jarg1;
47219   arg2 = (unsigned int)jarg2;
47220   arg3 = (Dali::Pixel::Format)jarg3;
47221   {
47222     try {
47223       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47224     } catch (std::out_of_range& e) {
47225       {
47226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47227       };
47228     } catch (std::exception& e) {
47229       {
47230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47231       };
47232     } catch (Dali::DaliException e) {
47233       {
47234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47235       };
47236     } catch (...) {
47237       {
47238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47239       };
47240     }
47241   }
47242
47243   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47244   return jresult;
47245 }
47246
47247
47248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47249   void * jresult ;
47250   unsigned int arg1 ;
47251   unsigned int arg2 ;
47252   Dali::FrameBufferImage result;
47253
47254   arg1 = (unsigned int)jarg1;
47255   arg2 = (unsigned int)jarg2;
47256   {
47257     try {
47258       result = Dali::FrameBufferImage::New(arg1,arg2);
47259     } catch (std::out_of_range& e) {
47260       {
47261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47262       };
47263     } catch (std::exception& e) {
47264       {
47265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47266       };
47267     } catch (Dali::DaliException e) {
47268       {
47269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47270       };
47271     } catch (...) {
47272       {
47273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47274       };
47275     }
47276   }
47277
47278   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47279   return jresult;
47280 }
47281
47282
47283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47284   void * jresult ;
47285   unsigned int arg1 ;
47286   Dali::FrameBufferImage result;
47287
47288   arg1 = (unsigned int)jarg1;
47289   {
47290     try {
47291       result = Dali::FrameBufferImage::New(arg1);
47292     } catch (std::out_of_range& e) {
47293       {
47294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47295       };
47296     } catch (std::exception& e) {
47297       {
47298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47299       };
47300     } catch (Dali::DaliException e) {
47301       {
47302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47303       };
47304     } catch (...) {
47305       {
47306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47307       };
47308     }
47309   }
47310
47311   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47312   return jresult;
47313 }
47314
47315
47316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47317   void * jresult ;
47318   Dali::FrameBufferImage result;
47319
47320   {
47321     try {
47322       result = Dali::FrameBufferImage::New();
47323     } catch (std::out_of_range& e) {
47324       {
47325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47326       };
47327     } catch (std::exception& e) {
47328       {
47329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47330       };
47331     } catch (Dali::DaliException e) {
47332       {
47333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47334       };
47335     } catch (...) {
47336       {
47337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47338       };
47339     }
47340   }
47341
47342   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47343   return jresult;
47344 }
47345
47346
47347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47348   void * jresult ;
47349   Dali::NativeImageInterface *arg1 = 0 ;
47350   Dali::FrameBufferImage result;
47351
47352   arg1 = (Dali::NativeImageInterface *)jarg1;
47353   if (!arg1) {
47354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47355     return 0;
47356   }
47357   {
47358     try {
47359       result = Dali::FrameBufferImage::New(*arg1);
47360     } catch (std::out_of_range& e) {
47361       {
47362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47363       };
47364     } catch (std::exception& e) {
47365       {
47366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47367       };
47368     } catch (Dali::DaliException e) {
47369       {
47370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47371       };
47372     } catch (...) {
47373       {
47374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47375       };
47376     }
47377   }
47378
47379   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47380   return jresult;
47381 }
47382
47383
47384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47385   void * jresult ;
47386   Dali::BaseHandle arg1 ;
47387   Dali::BaseHandle *argp1 ;
47388   Dali::FrameBufferImage result;
47389
47390   argp1 = (Dali::BaseHandle *)jarg1;
47391   if (!argp1) {
47392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47393     return 0;
47394   }
47395   arg1 = *argp1;
47396   {
47397     try {
47398       result = Dali::FrameBufferImage::DownCast(arg1);
47399     } catch (std::out_of_range& e) {
47400       {
47401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47402       };
47403     } catch (std::exception& e) {
47404       {
47405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47406       };
47407     } catch (Dali::DaliException e) {
47408       {
47409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47410       };
47411     } catch (...) {
47412       {
47413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47414       };
47415     }
47416   }
47417
47418   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47419   return jresult;
47420 }
47421
47422
47423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47424   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47425
47426   arg1 = (Dali::FrameBufferImage *)jarg1;
47427   {
47428     try {
47429       delete arg1;
47430     } catch (std::out_of_range& e) {
47431       {
47432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47433       };
47434     } catch (std::exception& e) {
47435       {
47436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47437       };
47438     } catch (Dali::DaliException e) {
47439       {
47440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47441       };
47442     } catch (...) {
47443       {
47444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47445       };
47446     }
47447   }
47448
47449 }
47450
47451
47452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47453   void * jresult ;
47454   Dali::FrameBufferImage *arg1 = 0 ;
47455   Dali::FrameBufferImage *result = 0 ;
47456
47457   arg1 = (Dali::FrameBufferImage *)jarg1;
47458   if (!arg1) {
47459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47460     return 0;
47461   }
47462   {
47463     try {
47464       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47465     } catch (std::out_of_range& e) {
47466       {
47467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47468       };
47469     } catch (std::exception& e) {
47470       {
47471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47472       };
47473     } catch (Dali::DaliException e) {
47474       {
47475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47476       };
47477     } catch (...) {
47478       {
47479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47480       };
47481     }
47482   }
47483
47484   jresult = (void *)result;
47485   return jresult;
47486 }
47487
47488
47489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47490   void * jresult ;
47491   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47492   Dali::FrameBufferImage *arg2 = 0 ;
47493   Dali::FrameBufferImage *result = 0 ;
47494
47495   arg1 = (Dali::FrameBufferImage *)jarg1;
47496   arg2 = (Dali::FrameBufferImage *)jarg2;
47497   if (!arg2) {
47498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47499     return 0;
47500   }
47501   {
47502     try {
47503       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47504     } catch (std::out_of_range& e) {
47505       {
47506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47507       };
47508     } catch (std::exception& e) {
47509       {
47510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47511       };
47512     } catch (Dali::DaliException e) {
47513       {
47514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47515       };
47516     } catch (...) {
47517       {
47518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47519       };
47520     }
47521   }
47522
47523   jresult = (void *)result;
47524   return jresult;
47525 }
47526
47527
47528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47529   void * jresult ;
47530   Dali::NinePatchImage *result = 0 ;
47531
47532   {
47533     try {
47534       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47535     } catch (std::out_of_range& e) {
47536       {
47537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47538       };
47539     } catch (std::exception& e) {
47540       {
47541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47542       };
47543     } catch (Dali::DaliException e) {
47544       {
47545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47546       };
47547     } catch (...) {
47548       {
47549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47550       };
47551     }
47552   }
47553
47554   jresult = (void *)result;
47555   return jresult;
47556 }
47557
47558
47559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47560   void * jresult ;
47561   std::string *arg1 = 0 ;
47562   Dali::NinePatchImage result;
47563
47564   if (!jarg1) {
47565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47566     return 0;
47567   }
47568   std::string arg1_str(jarg1);
47569   arg1 = &arg1_str;
47570   {
47571     try {
47572       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47573     } catch (std::out_of_range& e) {
47574       {
47575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47576       };
47577     } catch (std::exception& e) {
47578       {
47579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47580       };
47581     } catch (Dali::DaliException e) {
47582       {
47583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47584       };
47585     } catch (...) {
47586       {
47587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47588       };
47589     }
47590   }
47591
47592   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47593
47594   //argout typemap for const std::string&
47595
47596   return jresult;
47597 }
47598
47599
47600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47601   void * jresult ;
47602   Dali::BaseHandle arg1 ;
47603   Dali::BaseHandle *argp1 ;
47604   Dali::NinePatchImage result;
47605
47606   argp1 = (Dali::BaseHandle *)jarg1;
47607   if (!argp1) {
47608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47609     return 0;
47610   }
47611   arg1 = *argp1;
47612   {
47613     try {
47614       result = Dali::NinePatchImage::DownCast(arg1);
47615     } catch (std::out_of_range& e) {
47616       {
47617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47618       };
47619     } catch (std::exception& e) {
47620       {
47621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47622       };
47623     } catch (Dali::DaliException e) {
47624       {
47625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47626       };
47627     } catch (...) {
47628       {
47629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47630       };
47631     }
47632   }
47633
47634   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47635   return jresult;
47636 }
47637
47638
47639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47640   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47641
47642   arg1 = (Dali::NinePatchImage *)jarg1;
47643   {
47644     try {
47645       delete arg1;
47646     } catch (std::out_of_range& e) {
47647       {
47648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47649       };
47650     } catch (std::exception& e) {
47651       {
47652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47653       };
47654     } catch (Dali::DaliException e) {
47655       {
47656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47657       };
47658     } catch (...) {
47659       {
47660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47661       };
47662     }
47663   }
47664
47665 }
47666
47667
47668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47669   void * jresult ;
47670   Dali::NinePatchImage *arg1 = 0 ;
47671   Dali::NinePatchImage *result = 0 ;
47672
47673   arg1 = (Dali::NinePatchImage *)jarg1;
47674   if (!arg1) {
47675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47676     return 0;
47677   }
47678   {
47679     try {
47680       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47681     } catch (std::out_of_range& e) {
47682       {
47683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47684       };
47685     } catch (std::exception& e) {
47686       {
47687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47688       };
47689     } catch (Dali::DaliException e) {
47690       {
47691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47692       };
47693     } catch (...) {
47694       {
47695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47696       };
47697     }
47698   }
47699
47700   jresult = (void *)result;
47701   return jresult;
47702 }
47703
47704
47705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47706   void * jresult ;
47707   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47708   Dali::NinePatchImage *arg2 = 0 ;
47709   Dali::NinePatchImage *result = 0 ;
47710
47711   arg1 = (Dali::NinePatchImage *)jarg1;
47712   arg2 = (Dali::NinePatchImage *)jarg2;
47713   if (!arg2) {
47714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47715     return 0;
47716   }
47717   {
47718     try {
47719       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47720     } catch (std::out_of_range& e) {
47721       {
47722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47723       };
47724     } catch (std::exception& e) {
47725       {
47726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47727       };
47728     } catch (Dali::DaliException e) {
47729       {
47730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47731       };
47732     } catch (...) {
47733       {
47734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47735       };
47736     }
47737   }
47738
47739   jresult = (void *)result;
47740   return jresult;
47741 }
47742
47743
47744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47745   void * jresult ;
47746   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47747   Dali::Vector4 result;
47748
47749   arg1 = (Dali::NinePatchImage *)jarg1;
47750   {
47751     try {
47752       result = (arg1)->GetStretchBorders();
47753     } catch (std::out_of_range& e) {
47754       {
47755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47756       };
47757     } catch (std::exception& e) {
47758       {
47759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47760       };
47761     } catch (Dali::DaliException e) {
47762       {
47763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47764       };
47765     } catch (...) {
47766       {
47767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47768       };
47769     }
47770   }
47771
47772   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47773   return jresult;
47774 }
47775
47776
47777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47778   void * jresult ;
47779   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47780   Dali::NinePatchImage::StretchRanges *result = 0 ;
47781
47782   arg1 = (Dali::NinePatchImage *)jarg1;
47783   {
47784     try {
47785       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47786     } catch (std::out_of_range& e) {
47787       {
47788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47789       };
47790     } catch (std::exception& e) {
47791       {
47792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47793       };
47794     } catch (Dali::DaliException e) {
47795       {
47796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47797       };
47798     } catch (...) {
47799       {
47800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47801       };
47802     }
47803   }
47804
47805   jresult = (void *)result;
47806   return jresult;
47807 }
47808
47809
47810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47811   void * jresult ;
47812   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47813   Dali::NinePatchImage::StretchRanges *result = 0 ;
47814
47815   arg1 = (Dali::NinePatchImage *)jarg1;
47816   {
47817     try {
47818       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47819     } catch (std::out_of_range& e) {
47820       {
47821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47822       };
47823     } catch (std::exception& e) {
47824       {
47825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47826       };
47827     } catch (Dali::DaliException e) {
47828       {
47829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47830       };
47831     } catch (...) {
47832       {
47833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47834       };
47835     }
47836   }
47837
47838   jresult = (void *)result;
47839   return jresult;
47840 }
47841
47842
47843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47844   void * jresult ;
47845   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47846   Dali::Rect< int > result;
47847
47848   arg1 = (Dali::NinePatchImage *)jarg1;
47849   {
47850     try {
47851       result = (arg1)->GetChildRectangle();
47852     } catch (std::out_of_range& e) {
47853       {
47854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47855       };
47856     } catch (std::exception& e) {
47857       {
47858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47859       };
47860     } catch (Dali::DaliException e) {
47861       {
47862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47863       };
47864     } catch (...) {
47865       {
47866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47867       };
47868     }
47869   }
47870
47871   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47872   return jresult;
47873 }
47874
47875
47876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47877   void * jresult ;
47878   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47879   Dali::BufferImage result;
47880
47881   arg1 = (Dali::NinePatchImage *)jarg1;
47882   {
47883     try {
47884       result = (arg1)->CreateCroppedBufferImage();
47885     } catch (std::out_of_range& e) {
47886       {
47887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47888       };
47889     } catch (std::exception& e) {
47890       {
47891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47892       };
47893     } catch (Dali::DaliException e) {
47894       {
47895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47896       };
47897     } catch (...) {
47898       {
47899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47900       };
47901     }
47902   }
47903
47904   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47905   return jresult;
47906 }
47907
47908
47909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47910   unsigned int jresult ;
47911   std::string *arg1 = 0 ;
47912   bool result;
47913
47914   if (!jarg1) {
47915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47916     return 0;
47917   }
47918   std::string arg1_str(jarg1);
47919   arg1 = &arg1_str;
47920   {
47921     try {
47922       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47923     } catch (std::out_of_range& e) {
47924       {
47925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47926       };
47927     } catch (std::exception& e) {
47928       {
47929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47930       };
47931     } catch (Dali::DaliException e) {
47932       {
47933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47934       };
47935     } catch (...) {
47936       {
47937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47938       };
47939     }
47940   }
47941
47942   jresult = result;
47943
47944   //argout typemap for const std::string&
47945
47946   return jresult;
47947 }
47948
47949
47950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47951   int jresult ;
47952   int result;
47953
47954   result = (int)Dali::CameraActor::Property::TYPE;
47955   jresult = (int)result;
47956   return jresult;
47957 }
47958
47959
47960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47961   int jresult ;
47962   int result;
47963
47964   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47965   jresult = (int)result;
47966   return jresult;
47967 }
47968
47969
47970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47971   int jresult ;
47972   int result;
47973
47974   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47975   jresult = (int)result;
47976   return jresult;
47977 }
47978
47979
47980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47981   int jresult ;
47982   int result;
47983
47984   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47985   jresult = (int)result;
47986   return jresult;
47987 }
47988
47989
47990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47991   int jresult ;
47992   int result;
47993
47994   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47995   jresult = (int)result;
47996   return jresult;
47997 }
47998
47999
48000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48001   int jresult ;
48002   int result;
48003
48004   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48005   jresult = (int)result;
48006   return jresult;
48007 }
48008
48009
48010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48011   int jresult ;
48012   int result;
48013
48014   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48015   jresult = (int)result;
48016   return jresult;
48017 }
48018
48019
48020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48021   int jresult ;
48022   int result;
48023
48024   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48025   jresult = (int)result;
48026   return jresult;
48027 }
48028
48029
48030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48031   int jresult ;
48032   int result;
48033
48034   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48035   jresult = (int)result;
48036   return jresult;
48037 }
48038
48039
48040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48041   int jresult ;
48042   int result;
48043
48044   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48045   jresult = (int)result;
48046   return jresult;
48047 }
48048
48049
48050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48051   int jresult ;
48052   int result;
48053
48054   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48055   jresult = (int)result;
48056   return jresult;
48057 }
48058
48059
48060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48061   int jresult ;
48062   int result;
48063
48064   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48065   jresult = (int)result;
48066   return jresult;
48067 }
48068
48069
48070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48071   int jresult ;
48072   int result;
48073
48074   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48075   jresult = (int)result;
48076   return jresult;
48077 }
48078
48079
48080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48081   int jresult ;
48082   int result;
48083
48084   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48085   jresult = (int)result;
48086   return jresult;
48087 }
48088
48089
48090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48091   void * jresult ;
48092   Dali::CameraActor::Property *result = 0 ;
48093
48094   {
48095     try {
48096       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48097     } catch (std::out_of_range& e) {
48098       {
48099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48100       };
48101     } catch (std::exception& e) {
48102       {
48103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48104       };
48105     } catch (Dali::DaliException e) {
48106       {
48107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48108       };
48109     } catch (...) {
48110       {
48111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48112       };
48113     }
48114   }
48115
48116   jresult = (void *)result;
48117   return jresult;
48118 }
48119
48120
48121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48122   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48123
48124   arg1 = (Dali::CameraActor::Property *)jarg1;
48125   {
48126     try {
48127       delete arg1;
48128     } catch (std::out_of_range& e) {
48129       {
48130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48131       };
48132     } catch (std::exception& e) {
48133       {
48134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48135       };
48136     } catch (Dali::DaliException e) {
48137       {
48138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48139       };
48140     } catch (...) {
48141       {
48142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48143       };
48144     }
48145   }
48146
48147 }
48148
48149
48150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48151   void * jresult ;
48152   Dali::CameraActor *result = 0 ;
48153
48154   {
48155     try {
48156       result = (Dali::CameraActor *)new Dali::CameraActor();
48157     } catch (std::out_of_range& e) {
48158       {
48159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48160       };
48161     } catch (std::exception& e) {
48162       {
48163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48164       };
48165     } catch (Dali::DaliException e) {
48166       {
48167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48168       };
48169     } catch (...) {
48170       {
48171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48172       };
48173     }
48174   }
48175
48176   jresult = (void *)result;
48177   return jresult;
48178 }
48179
48180
48181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48182   void * jresult ;
48183   Dali::CameraActor result;
48184
48185   {
48186     try {
48187       result = Dali::CameraActor::New();
48188     } catch (std::out_of_range& e) {
48189       {
48190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48191       };
48192     } catch (std::exception& e) {
48193       {
48194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48195       };
48196     } catch (Dali::DaliException e) {
48197       {
48198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48199       };
48200     } catch (...) {
48201       {
48202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48203       };
48204     }
48205   }
48206
48207   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48208   return jresult;
48209 }
48210
48211
48212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48213   void * jresult ;
48214   Dali::Size *arg1 = 0 ;
48215   Dali::CameraActor result;
48216
48217   arg1 = (Dali::Size *)jarg1;
48218   if (!arg1) {
48219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48220     return 0;
48221   }
48222   {
48223     try {
48224       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48225     } catch (std::out_of_range& e) {
48226       {
48227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48228       };
48229     } catch (std::exception& e) {
48230       {
48231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48232       };
48233     } catch (Dali::DaliException e) {
48234       {
48235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48236       };
48237     } catch (...) {
48238       {
48239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48240       };
48241     }
48242   }
48243
48244   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48245   return jresult;
48246 }
48247
48248
48249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48250   void * jresult ;
48251   Dali::BaseHandle arg1 ;
48252   Dali::BaseHandle *argp1 ;
48253   Dali::CameraActor result;
48254
48255   argp1 = (Dali::BaseHandle *)jarg1;
48256   if (!argp1) {
48257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48258     return 0;
48259   }
48260   arg1 = *argp1;
48261   {
48262     try {
48263       result = Dali::CameraActor::DownCast(arg1);
48264     } catch (std::out_of_range& e) {
48265       {
48266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48267       };
48268     } catch (std::exception& e) {
48269       {
48270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48271       };
48272     } catch (Dali::DaliException e) {
48273       {
48274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48275       };
48276     } catch (...) {
48277       {
48278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48279       };
48280     }
48281   }
48282
48283   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48284   return jresult;
48285 }
48286
48287
48288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48289   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48290
48291   arg1 = (Dali::CameraActor *)jarg1;
48292   {
48293     try {
48294       delete arg1;
48295     } catch (std::out_of_range& e) {
48296       {
48297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48298       };
48299     } catch (std::exception& e) {
48300       {
48301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48302       };
48303     } catch (Dali::DaliException e) {
48304       {
48305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48306       };
48307     } catch (...) {
48308       {
48309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48310       };
48311     }
48312   }
48313
48314 }
48315
48316
48317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48318   void * jresult ;
48319   Dali::CameraActor *arg1 = 0 ;
48320   Dali::CameraActor *result = 0 ;
48321
48322   arg1 = (Dali::CameraActor *)jarg1;
48323   if (!arg1) {
48324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48325     return 0;
48326   }
48327   {
48328     try {
48329       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48330     } catch (std::out_of_range& e) {
48331       {
48332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48333       };
48334     } catch (std::exception& e) {
48335       {
48336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48337       };
48338     } catch (Dali::DaliException e) {
48339       {
48340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48341       };
48342     } catch (...) {
48343       {
48344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48345       };
48346     }
48347   }
48348
48349   jresult = (void *)result;
48350   return jresult;
48351 }
48352
48353
48354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48355   void * jresult ;
48356   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48357   Dali::CameraActor *arg2 = 0 ;
48358   Dali::CameraActor *result = 0 ;
48359
48360   arg1 = (Dali::CameraActor *)jarg1;
48361   arg2 = (Dali::CameraActor *)jarg2;
48362   if (!arg2) {
48363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48364     return 0;
48365   }
48366   {
48367     try {
48368       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48369     } catch (std::out_of_range& e) {
48370       {
48371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48372       };
48373     } catch (std::exception& e) {
48374       {
48375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48376       };
48377     } catch (Dali::DaliException e) {
48378       {
48379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48380       };
48381     } catch (...) {
48382       {
48383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48384       };
48385     }
48386   }
48387
48388   jresult = (void *)result;
48389   return jresult;
48390 }
48391
48392
48393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48394   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48395   Dali::Camera::Type arg2 ;
48396
48397   arg1 = (Dali::CameraActor *)jarg1;
48398   arg2 = (Dali::Camera::Type)jarg2;
48399   {
48400     try {
48401       (arg1)->SetType(arg2);
48402     } catch (std::out_of_range& e) {
48403       {
48404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48405       };
48406     } catch (std::exception& e) {
48407       {
48408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48409       };
48410     } catch (Dali::DaliException e) {
48411       {
48412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48413       };
48414     } catch (...) {
48415       {
48416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48417       };
48418     }
48419   }
48420
48421 }
48422
48423
48424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48425   int jresult ;
48426   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48427   Dali::Camera::Type result;
48428
48429   arg1 = (Dali::CameraActor *)jarg1;
48430   {
48431     try {
48432       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48433     } catch (std::out_of_range& e) {
48434       {
48435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48436       };
48437     } catch (std::exception& e) {
48438       {
48439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48440       };
48441     } catch (Dali::DaliException e) {
48442       {
48443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48444       };
48445     } catch (...) {
48446       {
48447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48448       };
48449     }
48450   }
48451
48452   jresult = (int)result;
48453   return jresult;
48454 }
48455
48456
48457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48458   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48459   Dali::Camera::ProjectionMode arg2 ;
48460
48461   arg1 = (Dali::CameraActor *)jarg1;
48462   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48463   {
48464     try {
48465       (arg1)->SetProjectionMode(arg2);
48466     } catch (std::out_of_range& e) {
48467       {
48468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48469       };
48470     } catch (std::exception& e) {
48471       {
48472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48473       };
48474     } catch (Dali::DaliException e) {
48475       {
48476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48477       };
48478     } catch (...) {
48479       {
48480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48481       };
48482     }
48483   }
48484
48485 }
48486
48487
48488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48489   int jresult ;
48490   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48491   Dali::Camera::ProjectionMode result;
48492
48493   arg1 = (Dali::CameraActor *)jarg1;
48494   {
48495     try {
48496       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48497     } catch (std::out_of_range& e) {
48498       {
48499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48500       };
48501     } catch (std::exception& e) {
48502       {
48503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48504       };
48505     } catch (Dali::DaliException e) {
48506       {
48507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48508       };
48509     } catch (...) {
48510       {
48511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48512       };
48513     }
48514   }
48515
48516   jresult = (int)result;
48517   return jresult;
48518 }
48519
48520
48521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48522   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48523   float arg2 ;
48524
48525   arg1 = (Dali::CameraActor *)jarg1;
48526   arg2 = (float)jarg2;
48527   {
48528     try {
48529       (arg1)->SetFieldOfView(arg2);
48530     } catch (std::out_of_range& e) {
48531       {
48532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48533       };
48534     } catch (std::exception& e) {
48535       {
48536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48537       };
48538     } catch (Dali::DaliException e) {
48539       {
48540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48541       };
48542     } catch (...) {
48543       {
48544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48545       };
48546     }
48547   }
48548
48549 }
48550
48551
48552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48553   float jresult ;
48554   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48555   float result;
48556
48557   arg1 = (Dali::CameraActor *)jarg1;
48558   {
48559     try {
48560       result = (float)(arg1)->GetFieldOfView();
48561     } catch (std::out_of_range& e) {
48562       {
48563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48564       };
48565     } catch (std::exception& e) {
48566       {
48567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48568       };
48569     } catch (Dali::DaliException e) {
48570       {
48571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48572       };
48573     } catch (...) {
48574       {
48575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48576       };
48577     }
48578   }
48579
48580   jresult = result;
48581   return jresult;
48582 }
48583
48584
48585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48586   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48587   float arg2 ;
48588
48589   arg1 = (Dali::CameraActor *)jarg1;
48590   arg2 = (float)jarg2;
48591   {
48592     try {
48593       (arg1)->SetAspectRatio(arg2);
48594     } catch (std::out_of_range& e) {
48595       {
48596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48597       };
48598     } catch (std::exception& e) {
48599       {
48600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48601       };
48602     } catch (Dali::DaliException e) {
48603       {
48604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48605       };
48606     } catch (...) {
48607       {
48608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48609       };
48610     }
48611   }
48612
48613 }
48614
48615
48616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48617   float jresult ;
48618   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48619   float result;
48620
48621   arg1 = (Dali::CameraActor *)jarg1;
48622   {
48623     try {
48624       result = (float)(arg1)->GetAspectRatio();
48625     } catch (std::out_of_range& e) {
48626       {
48627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48628       };
48629     } catch (std::exception& e) {
48630       {
48631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48632       };
48633     } catch (Dali::DaliException e) {
48634       {
48635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48636       };
48637     } catch (...) {
48638       {
48639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48640       };
48641     }
48642   }
48643
48644   jresult = result;
48645   return jresult;
48646 }
48647
48648
48649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48650   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48651   float arg2 ;
48652
48653   arg1 = (Dali::CameraActor *)jarg1;
48654   arg2 = (float)jarg2;
48655   {
48656     try {
48657       (arg1)->SetNearClippingPlane(arg2);
48658     } catch (std::out_of_range& e) {
48659       {
48660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48661       };
48662     } catch (std::exception& e) {
48663       {
48664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48665       };
48666     } catch (Dali::DaliException e) {
48667       {
48668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48669       };
48670     } catch (...) {
48671       {
48672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48673       };
48674     }
48675   }
48676
48677 }
48678
48679
48680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48681   float jresult ;
48682   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48683   float result;
48684
48685   arg1 = (Dali::CameraActor *)jarg1;
48686   {
48687     try {
48688       result = (float)(arg1)->GetNearClippingPlane();
48689     } catch (std::out_of_range& e) {
48690       {
48691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48692       };
48693     } catch (std::exception& e) {
48694       {
48695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48696       };
48697     } catch (Dali::DaliException e) {
48698       {
48699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48700       };
48701     } catch (...) {
48702       {
48703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48704       };
48705     }
48706   }
48707
48708   jresult = result;
48709   return jresult;
48710 }
48711
48712
48713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48714   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48715   float arg2 ;
48716
48717   arg1 = (Dali::CameraActor *)jarg1;
48718   arg2 = (float)jarg2;
48719   {
48720     try {
48721       (arg1)->SetFarClippingPlane(arg2);
48722     } catch (std::out_of_range& e) {
48723       {
48724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48725       };
48726     } catch (std::exception& e) {
48727       {
48728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48729       };
48730     } catch (Dali::DaliException e) {
48731       {
48732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48733       };
48734     } catch (...) {
48735       {
48736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48737       };
48738     }
48739   }
48740
48741 }
48742
48743
48744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48745   float jresult ;
48746   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48747   float result;
48748
48749   arg1 = (Dali::CameraActor *)jarg1;
48750   {
48751     try {
48752       result = (float)(arg1)->GetFarClippingPlane();
48753     } catch (std::out_of_range& e) {
48754       {
48755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48756       };
48757     } catch (std::exception& e) {
48758       {
48759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48760       };
48761     } catch (Dali::DaliException e) {
48762       {
48763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48764       };
48765     } catch (...) {
48766       {
48767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48768       };
48769     }
48770   }
48771
48772   jresult = result;
48773   return jresult;
48774 }
48775
48776
48777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48778   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48779   Dali::Vector3 *arg2 = 0 ;
48780
48781   arg1 = (Dali::CameraActor *)jarg1;
48782   arg2 = (Dali::Vector3 *)jarg2;
48783   if (!arg2) {
48784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48785     return ;
48786   }
48787   {
48788     try {
48789       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48790     } catch (std::out_of_range& e) {
48791       {
48792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48793       };
48794     } catch (std::exception& e) {
48795       {
48796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48797       };
48798     } catch (Dali::DaliException e) {
48799       {
48800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48801       };
48802     } catch (...) {
48803       {
48804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48805       };
48806     }
48807   }
48808
48809 }
48810
48811
48812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48813   void * jresult ;
48814   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48815   Dali::Vector3 result;
48816
48817   arg1 = (Dali::CameraActor *)jarg1;
48818   {
48819     try {
48820       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48821     } catch (std::out_of_range& e) {
48822       {
48823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48824       };
48825     } catch (std::exception& e) {
48826       {
48827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48828       };
48829     } catch (Dali::DaliException e) {
48830       {
48831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48832       };
48833     } catch (...) {
48834       {
48835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48836       };
48837     }
48838   }
48839
48840   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48841   return jresult;
48842 }
48843
48844
48845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48846   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48847   bool arg2 ;
48848
48849   arg1 = (Dali::CameraActor *)jarg1;
48850   arg2 = jarg2 ? true : false;
48851   {
48852     try {
48853       (arg1)->SetInvertYAxis(arg2);
48854     } catch (std::out_of_range& e) {
48855       {
48856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48857       };
48858     } catch (std::exception& e) {
48859       {
48860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48861       };
48862     } catch (Dali::DaliException e) {
48863       {
48864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48865       };
48866     } catch (...) {
48867       {
48868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48869       };
48870     }
48871   }
48872
48873 }
48874
48875
48876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48877   unsigned int jresult ;
48878   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48879   bool result;
48880
48881   arg1 = (Dali::CameraActor *)jarg1;
48882   {
48883     try {
48884       result = (bool)(arg1)->GetInvertYAxis();
48885     } catch (std::out_of_range& e) {
48886       {
48887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48888       };
48889     } catch (std::exception& e) {
48890       {
48891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48892       };
48893     } catch (Dali::DaliException e) {
48894       {
48895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48896       };
48897     } catch (...) {
48898       {
48899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48900       };
48901     }
48902   }
48903
48904   jresult = result;
48905   return jresult;
48906 }
48907
48908
48909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48910   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48911   Dali::Size *arg2 = 0 ;
48912
48913   arg1 = (Dali::CameraActor *)jarg1;
48914   arg2 = (Dali::Size *)jarg2;
48915   if (!arg2) {
48916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48917     return ;
48918   }
48919   {
48920     try {
48921       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48922     } catch (std::out_of_range& e) {
48923       {
48924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48925       };
48926     } catch (std::exception& e) {
48927       {
48928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48929       };
48930     } catch (Dali::DaliException e) {
48931       {
48932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48933       };
48934     } catch (...) {
48935       {
48936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48937       };
48938     }
48939   }
48940
48941 }
48942
48943
48944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48945   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48946   Dali::Size *arg2 = 0 ;
48947
48948   arg1 = (Dali::CameraActor *)jarg1;
48949   arg2 = (Dali::Size *)jarg2;
48950   if (!arg2) {
48951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48952     return ;
48953   }
48954   {
48955     try {
48956       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48957     } catch (std::out_of_range& e) {
48958       {
48959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48960       };
48961     } catch (std::exception& e) {
48962       {
48963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48964       };
48965     } catch (Dali::DaliException e) {
48966       {
48967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48968       };
48969     } catch (...) {
48970       {
48971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48972       };
48973     }
48974   }
48975
48976 }
48977
48978
48979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48980   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48981   float arg2 ;
48982   float arg3 ;
48983   float arg4 ;
48984   float arg5 ;
48985   float arg6 ;
48986   float arg7 ;
48987
48988   arg1 = (Dali::CameraActor *)jarg1;
48989   arg2 = (float)jarg2;
48990   arg3 = (float)jarg3;
48991   arg4 = (float)jarg4;
48992   arg5 = (float)jarg5;
48993   arg6 = (float)jarg6;
48994   arg7 = (float)jarg7;
48995   {
48996     try {
48997       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48998     } catch (std::out_of_range& e) {
48999       {
49000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49001       };
49002     } catch (std::exception& e) {
49003       {
49004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49005       };
49006     } catch (Dali::DaliException e) {
49007       {
49008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49009       };
49010     } catch (...) {
49011       {
49012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49013       };
49014     }
49015   }
49016
49017 }
49018
49019
49020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49021   void * jresult ;
49022   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49023
49024   {
49025     try {
49026       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49027     } catch (std::out_of_range& e) {
49028       {
49029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49030       };
49031     } catch (std::exception& e) {
49032       {
49033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49034       };
49035     } catch (Dali::DaliException e) {
49036       {
49037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49038       };
49039     } catch (...) {
49040       {
49041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49042       };
49043     }
49044   }
49045
49046   jresult = (void *)result;
49047   return jresult;
49048 }
49049
49050
49051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49052   void * jresult ;
49053   std::string arg1 ;
49054   Dali::Property::Value arg2 ;
49055   Dali::Property::Value *argp2 ;
49056   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49057
49058   if (!jarg1) {
49059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49060     return 0;
49061   }
49062   (&arg1)->assign(jarg1);
49063   argp2 = (Dali::Property::Value *)jarg2;
49064   if (!argp2) {
49065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49066     return 0;
49067   }
49068   arg2 = *argp2;
49069   {
49070     try {
49071       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49072     } catch (std::out_of_range& e) {
49073       {
49074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49075       };
49076     } catch (std::exception& e) {
49077       {
49078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49079       };
49080     } catch (Dali::DaliException e) {
49081       {
49082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49083       };
49084     } catch (...) {
49085       {
49086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49087       };
49088     }
49089   }
49090
49091   jresult = (void *)result;
49092   return jresult;
49093 }
49094
49095
49096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49097   void * jresult ;
49098   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49099   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49100
49101   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49102   if (!arg1) {
49103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49104     return 0;
49105   }
49106   {
49107     try {
49108       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);
49109     } catch (std::out_of_range& e) {
49110       {
49111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49112       };
49113     } catch (std::exception& e) {
49114       {
49115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49116       };
49117     } catch (Dali::DaliException e) {
49118       {
49119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49120       };
49121     } catch (...) {
49122       {
49123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49124       };
49125     }
49126   }
49127
49128   jresult = (void *)result;
49129   return jresult;
49130 }
49131
49132
49133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49134   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49135   std::string *arg2 = 0 ;
49136
49137   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49138   if (!jarg2) {
49139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49140     return ;
49141   }
49142   std::string arg2_str(jarg2);
49143   arg2 = &arg2_str;
49144   if (arg1) (arg1)->first = *arg2;
49145
49146   //argout typemap for const std::string&
49147
49148 }
49149
49150
49151 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49152   char * jresult ;
49153   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49154   std::string *result = 0 ;
49155
49156   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49157   result = (std::string *) & ((arg1)->first);
49158   jresult = SWIG_csharp_string_callback(result->c_str());
49159   return jresult;
49160 }
49161
49162
49163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49164   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49165   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49166
49167   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49168   arg2 = (Dali::Property::Value *)jarg2;
49169   if (arg1) (arg1)->second = *arg2;
49170 }
49171
49172
49173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49174   void * jresult ;
49175   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49176   Dali::Property::Value *result = 0 ;
49177
49178   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49179   result = (Dali::Property::Value *)& ((arg1)->second);
49180   jresult = (void *)result;
49181   return jresult;
49182 }
49183
49184
49185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49186   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49187
49188   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49189   {
49190     try {
49191       delete arg1;
49192     } catch (std::out_of_range& e) {
49193       {
49194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49195       };
49196     } catch (std::exception& e) {
49197       {
49198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49199       };
49200     } catch (Dali::DaliException e) {
49201       {
49202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49203       };
49204     } catch (...) {
49205       {
49206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49207       };
49208     }
49209   }
49210
49211 }
49212
49213
49214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49215   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49216
49217   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49218   {
49219     try {
49220       (arg1)->clear();
49221     } catch (std::out_of_range& e) {
49222       {
49223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49224       };
49225     } catch (std::exception& e) {
49226       {
49227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49228       };
49229     } catch (Dali::DaliException e) {
49230       {
49231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49232       };
49233     } catch (...) {
49234       {
49235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49236       };
49237     }
49238   }
49239
49240 }
49241
49242
49243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49244   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49245   Dali::TouchPoint *arg2 = 0 ;
49246
49247   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49248   arg2 = (Dali::TouchPoint *)jarg2;
49249   if (!arg2) {
49250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49251     return ;
49252   }
49253   {
49254     try {
49255       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49256     } catch (std::out_of_range& e) {
49257       {
49258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49259       };
49260     } catch (std::exception& e) {
49261       {
49262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49263       };
49264     } catch (Dali::DaliException e) {
49265       {
49266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49267       };
49268     } catch (...) {
49269       {
49270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49271       };
49272     }
49273   }
49274
49275 }
49276
49277
49278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49279   unsigned long jresult ;
49280   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49281   std::vector< Dali::TouchPoint >::size_type result;
49282
49283   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49284   {
49285     try {
49286       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49287     } catch (std::out_of_range& e) {
49288       {
49289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49290       };
49291     } catch (std::exception& e) {
49292       {
49293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49294       };
49295     } catch (Dali::DaliException e) {
49296       {
49297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49298       };
49299     } catch (...) {
49300       {
49301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49302       };
49303     }
49304   }
49305
49306   jresult = (unsigned long)result;
49307   return jresult;
49308 }
49309
49310
49311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49312   unsigned long jresult ;
49313   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49314   std::vector< Dali::TouchPoint >::size_type result;
49315
49316   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49317   {
49318     try {
49319       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49320     } catch (std::out_of_range& e) {
49321       {
49322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49323       };
49324     } catch (std::exception& e) {
49325       {
49326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49327       };
49328     } catch (Dali::DaliException e) {
49329       {
49330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49331       };
49332     } catch (...) {
49333       {
49334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49335       };
49336     }
49337   }
49338
49339   jresult = (unsigned long)result;
49340   return jresult;
49341 }
49342
49343
49344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49345   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49346   std::vector< Dali::TouchPoint >::size_type arg2 ;
49347
49348   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49349   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49350   {
49351     try {
49352       (arg1)->reserve(arg2);
49353     } catch (std::out_of_range& e) {
49354       {
49355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49356       };
49357     } catch (std::exception& e) {
49358       {
49359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49360       };
49361     } catch (Dali::DaliException e) {
49362       {
49363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49364       };
49365     } catch (...) {
49366       {
49367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49368       };
49369     }
49370   }
49371
49372 }
49373
49374
49375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49376   void * jresult ;
49377   std::vector< Dali::TouchPoint > *result = 0 ;
49378
49379   {
49380     try {
49381       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49382     } catch (std::out_of_range& e) {
49383       {
49384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49385       };
49386     } catch (std::exception& e) {
49387       {
49388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49389       };
49390     } catch (Dali::DaliException e) {
49391       {
49392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49393       };
49394     } catch (...) {
49395       {
49396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49397       };
49398     }
49399   }
49400
49401   jresult = (void *)result;
49402   return jresult;
49403 }
49404
49405
49406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49407   void * jresult ;
49408   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49409   std::vector< Dali::TouchPoint > *result = 0 ;
49410
49411   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49412   if (!arg1) {
49413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49414     return 0;
49415   }
49416   {
49417     try {
49418       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49419     } catch (std::out_of_range& e) {
49420       {
49421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49422       };
49423     } catch (std::exception& e) {
49424       {
49425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49426       };
49427     } catch (Dali::DaliException e) {
49428       {
49429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49430       };
49431     } catch (...) {
49432       {
49433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49434       };
49435     }
49436   }
49437
49438   jresult = (void *)result;
49439   return jresult;
49440 }
49441
49442
49443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49444   void * jresult ;
49445   int arg1 ;
49446   std::vector< Dali::TouchPoint > *result = 0 ;
49447
49448   arg1 = (int)jarg1;
49449   {
49450     try {
49451       try {
49452         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49453       }
49454       catch(std::out_of_range &_e) {
49455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49456         return 0;
49457       }
49458
49459     } catch (std::out_of_range& e) {
49460       {
49461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49462       };
49463     } catch (std::exception& e) {
49464       {
49465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49466       };
49467     } catch (Dali::DaliException e) {
49468       {
49469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49470       };
49471     } catch (...) {
49472       {
49473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49474       };
49475     }
49476   }
49477
49478   jresult = (void *)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49484   void * jresult ;
49485   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49486   int arg2 ;
49487   SwigValueWrapper< Dali::TouchPoint > result;
49488
49489   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49490   arg2 = (int)jarg2;
49491   {
49492     try {
49493       try {
49494         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49495       }
49496       catch(std::out_of_range &_e) {
49497         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49498         return 0;
49499       }
49500
49501     } catch (std::out_of_range& e) {
49502       {
49503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49504       };
49505     } catch (std::exception& e) {
49506       {
49507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49508       };
49509     } catch (Dali::DaliException e) {
49510       {
49511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49512       };
49513     } catch (...) {
49514       {
49515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49516       };
49517     }
49518   }
49519
49520   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49521   return jresult;
49522 }
49523
49524
49525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49526   void * jresult ;
49527   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49528   int arg2 ;
49529   Dali::TouchPoint *result = 0 ;
49530
49531   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49532   arg2 = (int)jarg2;
49533   {
49534     try {
49535       try {
49536         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49537       }
49538       catch(std::out_of_range &_e) {
49539         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49540         return 0;
49541       }
49542
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49550       };
49551     } catch (Dali::DaliException e) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49554       };
49555     } catch (...) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49558       };
49559     }
49560   }
49561
49562   jresult = (void *)result;
49563   return jresult;
49564 }
49565
49566
49567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49568   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49569   int arg2 ;
49570   Dali::TouchPoint *arg3 = 0 ;
49571
49572   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49573   arg2 = (int)jarg2;
49574   arg3 = (Dali::TouchPoint *)jarg3;
49575   if (!arg3) {
49576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49577     return ;
49578   }
49579   {
49580     try {
49581       try {
49582         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49583       }
49584       catch(std::out_of_range &_e) {
49585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49586         return ;
49587       }
49588
49589     } catch (std::out_of_range& e) {
49590       {
49591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49592       };
49593     } catch (std::exception& e) {
49594       {
49595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49596       };
49597     } catch (Dali::DaliException e) {
49598       {
49599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49600       };
49601     } catch (...) {
49602       {
49603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49604       };
49605     }
49606   }
49607
49608 }
49609
49610
49611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49612   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49613   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49614
49615   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49616   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49617   if (!arg2) {
49618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49619     return ;
49620   }
49621   {
49622     try {
49623       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49624     } catch (std::out_of_range& e) {
49625       {
49626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49627       };
49628     } catch (std::exception& e) {
49629       {
49630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49631       };
49632     } catch (Dali::DaliException e) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49635       };
49636     } catch (...) {
49637       {
49638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49639       };
49640     }
49641   }
49642
49643 }
49644
49645
49646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49647   void * jresult ;
49648   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49649   int arg2 ;
49650   int arg3 ;
49651   std::vector< Dali::TouchPoint > *result = 0 ;
49652
49653   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49654   arg2 = (int)jarg2;
49655   arg3 = (int)jarg3;
49656   {
49657     try {
49658       try {
49659         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49660       }
49661       catch(std::out_of_range &_e) {
49662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49663         return 0;
49664       }
49665       catch(std::invalid_argument &_e) {
49666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49667         return 0;
49668       }
49669
49670     } catch (std::out_of_range& e) {
49671       {
49672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49673       };
49674     } catch (std::exception& e) {
49675       {
49676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49677       };
49678     } catch (Dali::DaliException e) {
49679       {
49680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49685       };
49686     }
49687   }
49688
49689   jresult = (void *)result;
49690   return jresult;
49691 }
49692
49693
49694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49695   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49696   int arg2 ;
49697   Dali::TouchPoint *arg3 = 0 ;
49698
49699   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49700   arg2 = (int)jarg2;
49701   arg3 = (Dali::TouchPoint *)jarg3;
49702   if (!arg3) {
49703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49704     return ;
49705   }
49706   {
49707     try {
49708       try {
49709         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49710       }
49711       catch(std::out_of_range &_e) {
49712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49713         return ;
49714       }
49715
49716     } catch (std::out_of_range& e) {
49717       {
49718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49719       };
49720     } catch (std::exception& e) {
49721       {
49722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49723       };
49724     } catch (Dali::DaliException e) {
49725       {
49726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49727       };
49728     } catch (...) {
49729       {
49730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49731       };
49732     }
49733   }
49734
49735 }
49736
49737
49738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49739   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49740   int arg2 ;
49741   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49742
49743   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49744   arg2 = (int)jarg2;
49745   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49746   if (!arg3) {
49747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49748     return ;
49749   }
49750   {
49751     try {
49752       try {
49753         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49754       }
49755       catch(std::out_of_range &_e) {
49756         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49757         return ;
49758       }
49759
49760     } catch (std::out_of_range& e) {
49761       {
49762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (std::exception& e) {
49765       {
49766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49767       };
49768     } catch (Dali::DaliException e) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49771       };
49772     } catch (...) {
49773       {
49774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49775       };
49776     }
49777   }
49778
49779 }
49780
49781
49782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49783   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49784   int arg2 ;
49785
49786   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49787   arg2 = (int)jarg2;
49788   {
49789     try {
49790       try {
49791         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49792       }
49793       catch(std::out_of_range &_e) {
49794         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49795         return ;
49796       }
49797
49798     } catch (std::out_of_range& e) {
49799       {
49800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49801       };
49802     } catch (std::exception& e) {
49803       {
49804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49805       };
49806     } catch (Dali::DaliException e) {
49807       {
49808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49809       };
49810     } catch (...) {
49811       {
49812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49813       };
49814     }
49815   }
49816
49817 }
49818
49819
49820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49821   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49822   int arg2 ;
49823   int arg3 ;
49824
49825   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49826   arg2 = (int)jarg2;
49827   arg3 = (int)jarg3;
49828   {
49829     try {
49830       try {
49831         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49832       }
49833       catch(std::out_of_range &_e) {
49834         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49835         return ;
49836       }
49837       catch(std::invalid_argument &_e) {
49838         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49839         return ;
49840       }
49841
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_Repeat(void * jarg1, int jarg2) {
49865   void * jresult ;
49866   Dali::TouchPoint *arg1 = 0 ;
49867   int arg2 ;
49868   std::vector< Dali::TouchPoint > *result = 0 ;
49869
49870   arg1 = (Dali::TouchPoint *)jarg1;
49871   if (!arg1) {
49872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49873     return 0;
49874   }
49875   arg2 = (int)jarg2;
49876   {
49877     try {
49878       try {
49879         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49880       }
49881       catch(std::out_of_range &_e) {
49882         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49883         return 0;
49884       }
49885
49886     } catch (std::out_of_range& e) {
49887       {
49888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49889       };
49890     } catch (std::exception& e) {
49891       {
49892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49893       };
49894     } catch (Dali::DaliException e) {
49895       {
49896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49897       };
49898     } catch (...) {
49899       {
49900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49901       };
49902     }
49903   }
49904
49905   jresult = (void *)result;
49906   return jresult;
49907 }
49908
49909
49910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49911   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49912
49913   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49914   {
49915     try {
49916       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49917     } catch (std::out_of_range& e) {
49918       {
49919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49920       };
49921     } catch (std::exception& e) {
49922       {
49923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49924       };
49925     } catch (Dali::DaliException e) {
49926       {
49927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49928       };
49929     } catch (...) {
49930       {
49931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49932       };
49933     }
49934   }
49935
49936 }
49937
49938
49939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49940   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49941   int arg2 ;
49942   int arg3 ;
49943
49944   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49945   arg2 = (int)jarg2;
49946   arg3 = (int)jarg3;
49947   {
49948     try {
49949       try {
49950         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49951       }
49952       catch(std::out_of_range &_e) {
49953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49954         return ;
49955       }
49956       catch(std::invalid_argument &_e) {
49957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49958         return ;
49959       }
49960
49961     } catch (std::out_of_range& e) {
49962       {
49963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (std::exception& e) {
49966       {
49967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49968       };
49969     } catch (Dali::DaliException e) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49972       };
49973     } catch (...) {
49974       {
49975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49976       };
49977     }
49978   }
49979
49980 }
49981
49982
49983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49984   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49985   int arg2 ;
49986   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49987
49988   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49989   arg2 = (int)jarg2;
49990   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49991   if (!arg3) {
49992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49993     return ;
49994   }
49995   {
49996     try {
49997       try {
49998         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49999       }
50000       catch(std::out_of_range &_e) {
50001         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50002         return ;
50003       }
50004
50005     } catch (std::out_of_range& e) {
50006       {
50007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50008       };
50009     } catch (std::exception& e) {
50010       {
50011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50012       };
50013     } catch (Dali::DaliException e) {
50014       {
50015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50016       };
50017     } catch (...) {
50018       {
50019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50020       };
50021     }
50022   }
50023
50024 }
50025
50026
50027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50028   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50029
50030   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50031   {
50032     try {
50033       delete arg1;
50034     } catch (std::out_of_range& e) {
50035       {
50036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50037       };
50038     } catch (std::exception& e) {
50039       {
50040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50041       };
50042     } catch (Dali::DaliException e) {
50043       {
50044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50045       };
50046     } catch (...) {
50047       {
50048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50049       };
50050     }
50051   }
50052
50053 }
50054
50055
50056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50057   void * jresult ;
50058   Dali::Rect< int > *result = 0 ;
50059
50060   {
50061     try {
50062       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50063     } catch (std::out_of_range& e) {
50064       {
50065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50066       };
50067     } catch (std::exception& e) {
50068       {
50069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50070       };
50071     } catch (Dali::DaliException e) {
50072       {
50073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50074       };
50075     } catch (...) {
50076       {
50077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50078       };
50079     }
50080   }
50081
50082   jresult = (void *)result;
50083   return jresult;
50084 }
50085
50086
50087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50088   void * jresult ;
50089   int arg1 ;
50090   int arg2 ;
50091   int arg3 ;
50092   int arg4 ;
50093   Dali::Rect< int > *result = 0 ;
50094
50095   arg1 = (int)jarg1;
50096   arg2 = (int)jarg2;
50097   arg3 = (int)jarg3;
50098   arg4 = (int)jarg4;
50099   {
50100     try {
50101       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50102     } catch (std::out_of_range& e) {
50103       {
50104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50105       };
50106     } catch (std::exception& e) {
50107       {
50108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50109       };
50110     } catch (Dali::DaliException e) {
50111       {
50112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50113       };
50114     } catch (...) {
50115       {
50116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50117       };
50118     }
50119   }
50120
50121   jresult = (void *)result;
50122   return jresult;
50123 }
50124
50125
50126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50127   void * jresult ;
50128   Dali::Rect< int > *arg1 = 0 ;
50129   Dali::Rect< int > *result = 0 ;
50130
50131   arg1 = (Dali::Rect< int > *)jarg1;
50132   if (!arg1) {
50133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50134     return 0;
50135   }
50136   {
50137     try {
50138       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50139     } catch (std::out_of_range& e) {
50140       {
50141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50142       };
50143     } catch (std::exception& e) {
50144       {
50145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50146       };
50147     } catch (Dali::DaliException e) {
50148       {
50149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50150       };
50151     } catch (...) {
50152       {
50153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50154       };
50155     }
50156   }
50157
50158   jresult = (void *)result;
50159   return jresult;
50160 }
50161
50162
50163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50164   void * jresult ;
50165   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50166   Dali::Rect< int > *arg2 = 0 ;
50167   Dali::Rect< int > *result = 0 ;
50168
50169   arg1 = (Dali::Rect< int > *)jarg1;
50170   arg2 = (Dali::Rect< int > *)jarg2;
50171   if (!arg2) {
50172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50173     return 0;
50174   }
50175   {
50176     try {
50177       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50178     } catch (std::out_of_range& e) {
50179       {
50180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50181       };
50182     } catch (std::exception& e) {
50183       {
50184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50185       };
50186     } catch (Dali::DaliException e) {
50187       {
50188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50189       };
50190     } catch (...) {
50191       {
50192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50193       };
50194     }
50195   }
50196
50197   jresult = (void *)result;
50198   return jresult;
50199 }
50200
50201
50202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50203   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50204   int arg2 ;
50205   int arg3 ;
50206   int arg4 ;
50207   int arg5 ;
50208
50209   arg1 = (Dali::Rect< int > *)jarg1;
50210   arg2 = (int)jarg2;
50211   arg3 = (int)jarg3;
50212   arg4 = (int)jarg4;
50213   arg5 = (int)jarg5;
50214   {
50215     try {
50216       (arg1)->Set(arg2,arg3,arg4,arg5);
50217     } catch (std::out_of_range& e) {
50218       {
50219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50220       };
50221     } catch (std::exception& e) {
50222       {
50223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50224       };
50225     } catch (Dali::DaliException e) {
50226       {
50227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50228       };
50229     } catch (...) {
50230       {
50231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50232       };
50233     }
50234   }
50235
50236 }
50237
50238
50239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50240   unsigned int jresult ;
50241   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50242   bool result;
50243
50244   arg1 = (Dali::Rect< int > *)jarg1;
50245   {
50246     try {
50247       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50248     } catch (std::out_of_range& e) {
50249       {
50250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50251       };
50252     } catch (std::exception& e) {
50253       {
50254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50255       };
50256     } catch (Dali::DaliException e) {
50257       {
50258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50259       };
50260     } catch (...) {
50261       {
50262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50263       };
50264     }
50265   }
50266
50267   jresult = result;
50268   return jresult;
50269 }
50270
50271
50272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50273   int jresult ;
50274   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50275   int result;
50276
50277   arg1 = (Dali::Rect< int > *)jarg1;
50278   {
50279     try {
50280       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50281     } catch (std::out_of_range& e) {
50282       {
50283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50284       };
50285     } catch (std::exception& e) {
50286       {
50287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50288       };
50289     } catch (Dali::DaliException e) {
50290       {
50291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50292       };
50293     } catch (...) {
50294       {
50295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50296       };
50297     }
50298   }
50299
50300   jresult = result;
50301   return jresult;
50302 }
50303
50304
50305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50306   int jresult ;
50307   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50308   int result;
50309
50310   arg1 = (Dali::Rect< int > *)jarg1;
50311   {
50312     try {
50313       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50314     } catch (std::out_of_range& e) {
50315       {
50316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50317       };
50318     } catch (std::exception& e) {
50319       {
50320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50321       };
50322     } catch (Dali::DaliException e) {
50323       {
50324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50325       };
50326     } catch (...) {
50327       {
50328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50329       };
50330     }
50331   }
50332
50333   jresult = result;
50334   return jresult;
50335 }
50336
50337
50338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50339   int jresult ;
50340   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50341   int result;
50342
50343   arg1 = (Dali::Rect< int > *)jarg1;
50344   {
50345     try {
50346       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50347     } catch (std::out_of_range& e) {
50348       {
50349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50350       };
50351     } catch (std::exception& e) {
50352       {
50353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50354       };
50355     } catch (Dali::DaliException e) {
50356       {
50357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50358       };
50359     } catch (...) {
50360       {
50361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50362       };
50363     }
50364   }
50365
50366   jresult = result;
50367   return jresult;
50368 }
50369
50370
50371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50372   int jresult ;
50373   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50374   int result;
50375
50376   arg1 = (Dali::Rect< int > *)jarg1;
50377   {
50378     try {
50379       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50380     } catch (std::out_of_range& e) {
50381       {
50382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50383       };
50384     } catch (std::exception& e) {
50385       {
50386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50387       };
50388     } catch (Dali::DaliException e) {
50389       {
50390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50391       };
50392     } catch (...) {
50393       {
50394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50395       };
50396     }
50397   }
50398
50399   jresult = result;
50400   return jresult;
50401 }
50402
50403
50404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50405   int jresult ;
50406   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50407   int result;
50408
50409   arg1 = (Dali::Rect< int > *)jarg1;
50410   {
50411     try {
50412       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50413     } catch (std::out_of_range& e) {
50414       {
50415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50416       };
50417     } catch (std::exception& e) {
50418       {
50419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50420       };
50421     } catch (Dali::DaliException e) {
50422       {
50423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50424       };
50425     } catch (...) {
50426       {
50427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50428       };
50429     }
50430   }
50431
50432   jresult = result;
50433   return jresult;
50434 }
50435
50436
50437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50438   unsigned int jresult ;
50439   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50440   Dali::Rect< int > *arg2 = 0 ;
50441   bool result;
50442
50443   arg1 = (Dali::Rect< int > *)jarg1;
50444   arg2 = (Dali::Rect< int > *)jarg2;
50445   if (!arg2) {
50446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50447     return 0;
50448   }
50449   {
50450     try {
50451       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50452     } catch (std::out_of_range& e) {
50453       {
50454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50455       };
50456     } catch (std::exception& e) {
50457       {
50458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50459       };
50460     } catch (Dali::DaliException e) {
50461       {
50462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50463       };
50464     } catch (...) {
50465       {
50466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50467       };
50468     }
50469   }
50470
50471   jresult = result;
50472   return jresult;
50473 }
50474
50475
50476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50477   unsigned int jresult ;
50478   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50479   Dali::Rect< int > *arg2 = 0 ;
50480   bool result;
50481
50482   arg1 = (Dali::Rect< int > *)jarg1;
50483   arg2 = (Dali::Rect< int > *)jarg2;
50484   if (!arg2) {
50485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50486     return 0;
50487   }
50488   {
50489     try {
50490       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50491     } catch (std::out_of_range& e) {
50492       {
50493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50494       };
50495     } catch (std::exception& e) {
50496       {
50497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50498       };
50499     } catch (Dali::DaliException e) {
50500       {
50501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50502       };
50503     } catch (...) {
50504       {
50505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50506       };
50507     }
50508   }
50509
50510   jresult = result;
50511   return jresult;
50512 }
50513
50514
50515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50516   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50517   int arg2 ;
50518
50519   arg1 = (Dali::Rect< int > *)jarg1;
50520   arg2 = (int)jarg2;
50521   if (arg1) (arg1)->x = arg2;
50522 }
50523
50524
50525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50526   int jresult ;
50527   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50528   int result;
50529
50530   arg1 = (Dali::Rect< int > *)jarg1;
50531   result = (int) ((arg1)->x);
50532   jresult = result;
50533   return jresult;
50534 }
50535
50536
50537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50538   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50539   int arg2 ;
50540
50541   arg1 = (Dali::Rect< int > *)jarg1;
50542   arg2 = (int)jarg2;
50543   if (arg1) (arg1)->left = arg2;
50544 }
50545
50546
50547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50548   int jresult ;
50549   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50550   int result;
50551
50552   arg1 = (Dali::Rect< int > *)jarg1;
50553   result = (int) ((arg1)->left);
50554   jresult = result;
50555   return jresult;
50556 }
50557
50558
50559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50560   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50561   int arg2 ;
50562
50563   arg1 = (Dali::Rect< int > *)jarg1;
50564   arg2 = (int)jarg2;
50565   if (arg1) (arg1)->y = arg2;
50566 }
50567
50568
50569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50570   int jresult ;
50571   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50572   int result;
50573
50574   arg1 = (Dali::Rect< int > *)jarg1;
50575   result = (int) ((arg1)->y);
50576   jresult = result;
50577   return jresult;
50578 }
50579
50580
50581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50582   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50583   int arg2 ;
50584
50585   arg1 = (Dali::Rect< int > *)jarg1;
50586   arg2 = (int)jarg2;
50587   if (arg1) (arg1)->right = arg2;
50588 }
50589
50590
50591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50592   int jresult ;
50593   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50594   int result;
50595
50596   arg1 = (Dali::Rect< int > *)jarg1;
50597   result = (int) ((arg1)->right);
50598   jresult = result;
50599   return jresult;
50600 }
50601
50602
50603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50604   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50605   int arg2 ;
50606
50607   arg1 = (Dali::Rect< int > *)jarg1;
50608   arg2 = (int)jarg2;
50609   if (arg1) (arg1)->width = arg2;
50610 }
50611
50612
50613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50614   int jresult ;
50615   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50616   int result;
50617
50618   arg1 = (Dali::Rect< int > *)jarg1;
50619   result = (int) ((arg1)->width);
50620   jresult = result;
50621   return jresult;
50622 }
50623
50624
50625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50626   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50627   int arg2 ;
50628
50629   arg1 = (Dali::Rect< int > *)jarg1;
50630   arg2 = (int)jarg2;
50631   if (arg1) (arg1)->bottom = arg2;
50632 }
50633
50634
50635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50636   int jresult ;
50637   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50638   int result;
50639
50640   arg1 = (Dali::Rect< int > *)jarg1;
50641   result = (int) ((arg1)->bottom);
50642   jresult = result;
50643   return jresult;
50644 }
50645
50646
50647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50648   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50649   int arg2 ;
50650
50651   arg1 = (Dali::Rect< int > *)jarg1;
50652   arg2 = (int)jarg2;
50653   if (arg1) (arg1)->height = arg2;
50654 }
50655
50656
50657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50658   int jresult ;
50659   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50660   int result;
50661
50662   arg1 = (Dali::Rect< int > *)jarg1;
50663   result = (int) ((arg1)->height);
50664   jresult = result;
50665   return jresult;
50666 }
50667
50668
50669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50670   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50671   int arg2 ;
50672
50673   arg1 = (Dali::Rect< int > *)jarg1;
50674   arg2 = (int)jarg2;
50675   if (arg1) (arg1)->top = arg2;
50676 }
50677
50678
50679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50680   int jresult ;
50681   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50682   int result;
50683
50684   arg1 = (Dali::Rect< int > *)jarg1;
50685   result = (int) ((arg1)->top);
50686   jresult = result;
50687   return jresult;
50688 }
50689
50690
50691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50692   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50693
50694   arg1 = (Dali::Rect< int > *)jarg1;
50695   {
50696     try {
50697       delete arg1;
50698     } catch (std::out_of_range& e) {
50699       {
50700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50701       };
50702     } catch (std::exception& e) {
50703       {
50704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50705       };
50706     } catch (Dali::DaliException e) {
50707       {
50708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50709       };
50710     } catch (...) {
50711       {
50712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50713       };
50714     }
50715   }
50716
50717 }
50718
50719
50720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50721   void * jresult ;
50722   Dali::Rect< float > *result = 0 ;
50723
50724   {
50725     try {
50726       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50727     } catch (std::out_of_range& e) {
50728       {
50729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50730       };
50731     } catch (std::exception& e) {
50732       {
50733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50734       };
50735     } catch (Dali::DaliException e) {
50736       {
50737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50738       };
50739     } catch (...) {
50740       {
50741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50742       };
50743     }
50744   }
50745
50746   jresult = (void *)result;
50747   return jresult;
50748 }
50749
50750
50751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50752   void * jresult ;
50753   float arg1 ;
50754   float arg2 ;
50755   float arg3 ;
50756   float arg4 ;
50757   Dali::Rect< float > *result = 0 ;
50758
50759   arg1 = (float)jarg1;
50760   arg2 = (float)jarg2;
50761   arg3 = (float)jarg4;
50762   arg4 = (float)jarg3;
50763   {
50764     try {
50765       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50766     } catch (std::out_of_range& e) {
50767       {
50768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50769       };
50770     } catch (std::exception& e) {
50771       {
50772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50773       };
50774     } catch (Dali::DaliException e) {
50775       {
50776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50777       };
50778     } catch (...) {
50779       {
50780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50781       };
50782     }
50783   }
50784
50785   jresult = (void *)result;
50786   return jresult;
50787 }
50788
50789
50790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50791   void * jresult ;
50792   Dali::Rect< float > *arg1 = 0 ;
50793   Dali::Rect< float > *result = 0 ;
50794
50795   arg1 = (Dali::Rect< float > *)jarg1;
50796   if (!arg1) {
50797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50798     return 0;
50799   }
50800   {
50801     try {
50802       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50803     } catch (std::out_of_range& e) {
50804       {
50805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50806       };
50807     } catch (std::exception& e) {
50808       {
50809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50810       };
50811     } catch (Dali::DaliException e) {
50812       {
50813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50814       };
50815     } catch (...) {
50816       {
50817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50818       };
50819     }
50820   }
50821
50822   jresult = (void *)result;
50823   return jresult;
50824 }
50825
50826
50827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50828   void * jresult ;
50829   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50830   Dali::Rect< float > *arg2 = 0 ;
50831   Dali::Rect< float > *result = 0 ;
50832
50833   arg1 = (Dali::Rect< float > *)jarg1;
50834   arg2 = (Dali::Rect< float > *)jarg2;
50835   if (!arg2) {
50836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50837     return 0;
50838   }
50839   {
50840     try {
50841       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50842     } catch (std::out_of_range& e) {
50843       {
50844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50845       };
50846     } catch (std::exception& e) {
50847       {
50848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50849       };
50850     } catch (Dali::DaliException e) {
50851       {
50852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50853       };
50854     } catch (...) {
50855       {
50856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50857       };
50858     }
50859   }
50860
50861   jresult = (void *)result;
50862   return jresult;
50863 }
50864
50865
50866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50867   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50868   float arg2 ;
50869   float arg3 ;
50870   float arg4 ;
50871   float arg5 ;
50872
50873   arg1 = (Dali::Rect< float > *)jarg1;
50874   arg2 = (float)jarg2;
50875   arg3 = (float)jarg3;
50876   arg4 = (float)jarg5;
50877   arg5 = (float)jarg4;
50878   {
50879     try {
50880       (arg1)->Set(arg2,arg3,arg4,arg5);
50881     } catch (std::out_of_range& e) {
50882       {
50883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50884       };
50885     } catch (std::exception& e) {
50886       {
50887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50888       };
50889     } catch (Dali::DaliException e) {
50890       {
50891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50892       };
50893     } catch (...) {
50894       {
50895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50896       };
50897     }
50898   }
50899
50900 }
50901
50902
50903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50904   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50905   float arg2 ;
50906
50907   arg1 = (Dali::Rect< float > *)jarg1;
50908   arg2 = (float)jarg2;
50909   if (arg1) (arg1)->left = arg2;
50910 }
50911
50912
50913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50914   float jresult ;
50915   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50916   float result;
50917
50918   arg1 = (Dali::Rect< float > *)jarg1;
50919   result = (float) ((arg1)->left);
50920   jresult = result;
50921   return jresult;
50922 }
50923
50924
50925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50926   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50927   float arg2 ;
50928
50929   arg1 = (Dali::Rect< float > *)jarg1;
50930   arg2 = (float)jarg2;
50931   if (arg1) (arg1)->left = arg2;
50932 }
50933
50934
50935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50936   float jresult ;
50937   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50938   float result;
50939
50940   arg1 = (Dali::Rect< float > *)jarg1;
50941   result = (float) ((arg1)->left);
50942   jresult = result;
50943   return jresult;
50944 }
50945
50946
50947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50948   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50949   float arg2 ;
50950
50951   arg1 = (Dali::Rect< float > *)jarg1;
50952   arg2 = (float)jarg2;
50953   if (arg1) (arg1)->right = arg2;
50954 }
50955
50956
50957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50958   float jresult ;
50959   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50960   float result;
50961
50962   arg1 = (Dali::Rect< float > *)jarg1;
50963   result = (float) ((arg1)->right);
50964   jresult = result;
50965   return jresult;
50966 }
50967
50968
50969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50970   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50971   float arg2 ;
50972
50973   arg1 = (Dali::Rect< float > *)jarg1;
50974   arg2 = (float)jarg2;
50975   if (arg1) (arg1)->right = arg2;
50976 }
50977
50978
50979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50980   float jresult ;
50981   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50982   float result;
50983
50984   arg1 = (Dali::Rect< float > *)jarg1;
50985   result = (float) ((arg1)->right);
50986   jresult = result;
50987   return jresult;
50988 }
50989
50990
50991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50992   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50993   float arg2 ;
50994
50995   arg1 = (Dali::Rect< float > *)jarg1;
50996   arg2 = (float)jarg2;
50997   if (arg1) (arg1)->bottom = arg2;
50998 }
50999
51000
51001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51002   float jresult ;
51003   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51004   float result;
51005
51006   arg1 = (Dali::Rect< float > *)jarg1;
51007   result = (float) ((arg1)->bottom);
51008   jresult = result;
51009   return jresult;
51010 }
51011
51012
51013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51014   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51015   float arg2 ;
51016
51017   arg1 = (Dali::Rect< float > *)jarg1;
51018   arg2 = (float)jarg2;
51019   if (arg1) (arg1)->top = arg2;
51020 }
51021
51022
51023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51024   float jresult ;
51025   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51026   float result;
51027
51028   arg1 = (Dali::Rect< float > *)jarg1;
51029   result = (float) ((arg1)->top);
51030   jresult = result;
51031   return jresult;
51032 }
51033
51034
51035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51036   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51037
51038   arg1 = (Dali::Rect< float > *)jarg1;
51039   {
51040     try {
51041       delete arg1;
51042     } catch (std::out_of_range& e) {
51043       {
51044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51045       };
51046     } catch (std::exception& e) {
51047       {
51048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51049       };
51050     } catch (Dali::DaliException e) {
51051       {
51052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51053       };
51054     } catch (...) {
51055       {
51056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51057       };
51058     }
51059   }
51060
51061 }
51062
51063
51064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51065   int jresult ;
51066   int result;
51067
51068   result = (int)Dali::Vector< int >::BaseType;
51069   jresult = (int)result;
51070   return jresult;
51071 }
51072
51073
51074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51075   void * jresult ;
51076   Dali::Vector< int > *result = 0 ;
51077
51078   {
51079     try {
51080       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51081     } catch (std::out_of_range& e) {
51082       {
51083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51084       };
51085     } catch (std::exception& e) {
51086       {
51087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51088       };
51089     } catch (Dali::DaliException e) {
51090       {
51091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51092       };
51093     } catch (...) {
51094       {
51095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51096       };
51097     }
51098   }
51099
51100   jresult = (void *)result;
51101   return jresult;
51102 }
51103
51104
51105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51106   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51107
51108   arg1 = (Dali::Vector< int > *)jarg1;
51109   {
51110     try {
51111       delete arg1;
51112     } catch (std::out_of_range& e) {
51113       {
51114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51115       };
51116     } catch (std::exception& e) {
51117       {
51118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51119       };
51120     } catch (Dali::DaliException e) {
51121       {
51122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51123       };
51124     } catch (...) {
51125       {
51126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51127       };
51128     }
51129   }
51130
51131 }
51132
51133
51134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51135   void * jresult ;
51136   Dali::Vector< int > *arg1 = 0 ;
51137   Dali::Vector< int > *result = 0 ;
51138
51139   arg1 = (Dali::Vector< int > *)jarg1;
51140   if (!arg1) {
51141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51142     return 0;
51143   }
51144   {
51145     try {
51146       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51147     } catch (std::out_of_range& e) {
51148       {
51149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51150       };
51151     } catch (std::exception& e) {
51152       {
51153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51154       };
51155     } catch (Dali::DaliException e) {
51156       {
51157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51158       };
51159     } catch (...) {
51160       {
51161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51162       };
51163     }
51164   }
51165
51166   jresult = (void *)result;
51167   return jresult;
51168 }
51169
51170
51171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51172   void * jresult ;
51173   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51174   Dali::Vector< int > *arg2 = 0 ;
51175   Dali::Vector< int > *result = 0 ;
51176
51177   arg1 = (Dali::Vector< int > *)jarg1;
51178   arg2 = (Dali::Vector< int > *)jarg2;
51179   if (!arg2) {
51180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51181     return 0;
51182   }
51183   {
51184     try {
51185       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51186     } catch (std::out_of_range& e) {
51187       {
51188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51189       };
51190     } catch (std::exception& e) {
51191       {
51192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51193       };
51194     } catch (Dali::DaliException e) {
51195       {
51196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51197       };
51198     } catch (...) {
51199       {
51200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51201       };
51202     }
51203   }
51204
51205   jresult = (void *)result;
51206   return jresult;
51207 }
51208
51209
51210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51211   void * jresult ;
51212   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51213   Dali::Vector< int >::Iterator result;
51214
51215   arg1 = (Dali::Vector< int > *)jarg1;
51216   {
51217     try {
51218       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51219     } catch (std::out_of_range& e) {
51220       {
51221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51222       };
51223     } catch (std::exception& e) {
51224       {
51225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51226       };
51227     } catch (Dali::DaliException e) {
51228       {
51229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51230       };
51231     } catch (...) {
51232       {
51233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51234       };
51235     }
51236   }
51237
51238   jresult = (void *)result;
51239   return jresult;
51240 }
51241
51242
51243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51244   void * jresult ;
51245   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51246   Dali::Vector< int >::Iterator result;
51247
51248   arg1 = (Dali::Vector< int > *)jarg1;
51249   {
51250     try {
51251       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51252     } catch (std::out_of_range& e) {
51253       {
51254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51255       };
51256     } catch (std::exception& e) {
51257       {
51258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51259       };
51260     } catch (Dali::DaliException e) {
51261       {
51262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51263       };
51264     } catch (...) {
51265       {
51266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51267       };
51268     }
51269   }
51270
51271   jresult = (void *)result;
51272   return jresult;
51273 }
51274
51275
51276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51277   void * jresult ;
51278   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51279   Dali::Vector< int >::SizeType arg2 ;
51280   Dali::Vector< int >::ItemType *result = 0 ;
51281
51282   arg1 = (Dali::Vector< int > *)jarg1;
51283   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51284   {
51285     try {
51286       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51287     } catch (std::out_of_range& e) {
51288       {
51289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51290       };
51291     } catch (std::exception& e) {
51292       {
51293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51294       };
51295     } catch (Dali::DaliException e) {
51296       {
51297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51298       };
51299     } catch (...) {
51300       {
51301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51302       };
51303     }
51304   }
51305
51306   jresult = (void *)result;
51307   return jresult;
51308 }
51309
51310
51311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51312   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51313   Dali::Vector< int >::ItemType *arg2 = 0 ;
51314   Dali::Vector< int >::ItemType temp2 ;
51315
51316   arg1 = (Dali::Vector< int > *)jarg1;
51317   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51318   arg2 = &temp2;
51319   {
51320     try {
51321       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51322     } catch (std::out_of_range& e) {
51323       {
51324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51325       };
51326     } catch (std::exception& e) {
51327       {
51328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51329       };
51330     } catch (Dali::DaliException e) {
51331       {
51332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51333       };
51334     } catch (...) {
51335       {
51336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51337       };
51338     }
51339   }
51340
51341 }
51342
51343
51344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51345   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51346   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51347   Dali::Vector< int >::ItemType *arg3 = 0 ;
51348   Dali::Vector< int >::ItemType temp3 ;
51349
51350   arg1 = (Dali::Vector< int > *)jarg1;
51351   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51352   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51353   arg3 = &temp3;
51354   {
51355     try {
51356       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51357     } catch (std::out_of_range& e) {
51358       {
51359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51360       };
51361     } catch (std::exception& e) {
51362       {
51363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51364       };
51365     } catch (Dali::DaliException e) {
51366       {
51367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51368       };
51369     } catch (...) {
51370       {
51371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51372       };
51373     }
51374   }
51375
51376 }
51377
51378
51379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51380   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51381   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51382   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51383   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51384
51385   arg1 = (Dali::Vector< int > *)jarg1;
51386   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51387   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51388   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51389   {
51390     try {
51391       (arg1)->Insert(arg2,arg3,arg4);
51392     } catch (std::out_of_range& e) {
51393       {
51394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51395       };
51396     } catch (std::exception& e) {
51397       {
51398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51399       };
51400     } catch (Dali::DaliException e) {
51401       {
51402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51403       };
51404     } catch (...) {
51405       {
51406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51407       };
51408     }
51409   }
51410
51411 }
51412
51413
51414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51415   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51416   Dali::Vector< int >::SizeType arg2 ;
51417
51418   arg1 = (Dali::Vector< int > *)jarg1;
51419   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51420   {
51421     try {
51422       (arg1)->Reserve(arg2);
51423     } catch (std::out_of_range& e) {
51424       {
51425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51426       };
51427     } catch (std::exception& e) {
51428       {
51429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51430       };
51431     } catch (Dali::DaliException e) {
51432       {
51433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51434       };
51435     } catch (...) {
51436       {
51437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51438       };
51439     }
51440   }
51441
51442 }
51443
51444
51445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51446   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51447   Dali::Vector< int >::SizeType arg2 ;
51448
51449   arg1 = (Dali::Vector< int > *)jarg1;
51450   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51451   {
51452     try {
51453       (arg1)->Resize(arg2);
51454     } catch (std::out_of_range& e) {
51455       {
51456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51457       };
51458     } catch (std::exception& e) {
51459       {
51460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51461       };
51462     } catch (Dali::DaliException e) {
51463       {
51464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51465       };
51466     } catch (...) {
51467       {
51468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51469       };
51470     }
51471   }
51472
51473 }
51474
51475
51476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51477   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51478   Dali::Vector< int >::SizeType arg2 ;
51479   Dali::Vector< int >::ItemType *arg3 = 0 ;
51480   Dali::Vector< int >::ItemType temp3 ;
51481
51482   arg1 = (Dali::Vector< int > *)jarg1;
51483   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51484   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51485   arg3 = &temp3;
51486   {
51487     try {
51488       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51489     } catch (std::out_of_range& e) {
51490       {
51491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51492       };
51493     } catch (std::exception& e) {
51494       {
51495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51496       };
51497     } catch (Dali::DaliException e) {
51498       {
51499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51500       };
51501     } catch (...) {
51502       {
51503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51504       };
51505     }
51506   }
51507
51508 }
51509
51510
51511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51512   void * jresult ;
51513   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51514   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51515   Dali::Vector< int >::Iterator result;
51516
51517   arg1 = (Dali::Vector< int > *)jarg1;
51518   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51519   {
51520     try {
51521       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51522     } catch (std::out_of_range& e) {
51523       {
51524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51525       };
51526     } catch (std::exception& e) {
51527       {
51528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51529       };
51530     } catch (Dali::DaliException e) {
51531       {
51532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51533       };
51534     } catch (...) {
51535       {
51536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51537       };
51538     }
51539   }
51540
51541   jresult = (void *)result;
51542   return jresult;
51543 }
51544
51545
51546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51547   void * jresult ;
51548   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51549   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51550   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51551   Dali::Vector< int >::Iterator result;
51552
51553   arg1 = (Dali::Vector< int > *)jarg1;
51554   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51555   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51556   {
51557     try {
51558       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51559     } catch (std::out_of_range& e) {
51560       {
51561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51562       };
51563     } catch (std::exception& e) {
51564       {
51565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51566       };
51567     } catch (Dali::DaliException e) {
51568       {
51569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51570       };
51571     } catch (...) {
51572       {
51573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51574       };
51575     }
51576   }
51577
51578   jresult = (void *)result;
51579   return jresult;
51580 }
51581
51582
51583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51584   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51585   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51586
51587   arg1 = (Dali::Vector< int > *)jarg1;
51588   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51589   {
51590     try {
51591       (arg1)->Remove(arg2);
51592     } catch (std::out_of_range& e) {
51593       {
51594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51595       };
51596     } catch (std::exception& e) {
51597       {
51598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51599       };
51600     } catch (Dali::DaliException e) {
51601       {
51602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51603       };
51604     } catch (...) {
51605       {
51606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51607       };
51608     }
51609   }
51610
51611 }
51612
51613
51614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51615   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51616   Dali::Vector< int > *arg2 = 0 ;
51617
51618   arg1 = (Dali::Vector< int > *)jarg1;
51619   arg2 = (Dali::Vector< int > *)jarg2;
51620   if (!arg2) {
51621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51622     return ;
51623   }
51624   {
51625     try {
51626       (arg1)->Swap(*arg2);
51627     } catch (std::out_of_range& e) {
51628       {
51629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51630       };
51631     } catch (std::exception& e) {
51632       {
51633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51634       };
51635     } catch (Dali::DaliException e) {
51636       {
51637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51638       };
51639     } catch (...) {
51640       {
51641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51642       };
51643     }
51644   }
51645
51646 }
51647
51648
51649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51650   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51651
51652   arg1 = (Dali::Vector< int > *)jarg1;
51653   {
51654     try {
51655       (arg1)->Clear();
51656     } catch (std::out_of_range& e) {
51657       {
51658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51659       };
51660     } catch (std::exception& e) {
51661       {
51662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51663       };
51664     } catch (Dali::DaliException e) {
51665       {
51666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51667       };
51668     } catch (...) {
51669       {
51670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51671       };
51672     }
51673   }
51674
51675 }
51676
51677
51678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51679   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51680
51681   arg1 = (Dali::Vector< int > *)jarg1;
51682   {
51683     try {
51684       (arg1)->Release();
51685     } catch (std::out_of_range& e) {
51686       {
51687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51688       };
51689     } catch (std::exception& e) {
51690       {
51691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51692       };
51693     } catch (Dali::DaliException e) {
51694       {
51695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51696       };
51697     } catch (...) {
51698       {
51699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51700       };
51701     }
51702   }
51703
51704 }
51705
51706
51707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51708   int jresult ;
51709   int result;
51710
51711   result = (int)Dali::Vector< float >::BaseType;
51712   jresult = (int)result;
51713   return jresult;
51714 }
51715
51716
51717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51718   void * jresult ;
51719   Dali::Vector< float > *result = 0 ;
51720
51721   {
51722     try {
51723       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51724     } catch (std::out_of_range& e) {
51725       {
51726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51727       };
51728     } catch (std::exception& e) {
51729       {
51730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51731       };
51732     } catch (Dali::DaliException e) {
51733       {
51734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51735       };
51736     } catch (...) {
51737       {
51738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51739       };
51740     }
51741   }
51742
51743   jresult = (void *)result;
51744   return jresult;
51745 }
51746
51747
51748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51749   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51750
51751   arg1 = (Dali::Vector< float > *)jarg1;
51752   {
51753     try {
51754       delete arg1;
51755     } catch (std::out_of_range& e) {
51756       {
51757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51758       };
51759     } catch (std::exception& e) {
51760       {
51761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51762       };
51763     } catch (Dali::DaliException e) {
51764       {
51765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51766       };
51767     } catch (...) {
51768       {
51769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51770       };
51771     }
51772   }
51773
51774 }
51775
51776
51777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51778   void * jresult ;
51779   Dali::Vector< float > *arg1 = 0 ;
51780   Dali::Vector< float > *result = 0 ;
51781
51782   arg1 = (Dali::Vector< float > *)jarg1;
51783   if (!arg1) {
51784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51785     return 0;
51786   }
51787   {
51788     try {
51789       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51790     } catch (std::out_of_range& e) {
51791       {
51792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51793       };
51794     } catch (std::exception& e) {
51795       {
51796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51797       };
51798     } catch (Dali::DaliException e) {
51799       {
51800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51801       };
51802     } catch (...) {
51803       {
51804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51805       };
51806     }
51807   }
51808
51809   jresult = (void *)result;
51810   return jresult;
51811 }
51812
51813
51814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51815   void * jresult ;
51816   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51817   Dali::Vector< float > *arg2 = 0 ;
51818   Dali::Vector< float > *result = 0 ;
51819
51820   arg1 = (Dali::Vector< float > *)jarg1;
51821   arg2 = (Dali::Vector< float > *)jarg2;
51822   if (!arg2) {
51823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51824     return 0;
51825   }
51826   {
51827     try {
51828       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51829     } catch (std::out_of_range& e) {
51830       {
51831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51832       };
51833     } catch (std::exception& e) {
51834       {
51835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51836       };
51837     } catch (Dali::DaliException e) {
51838       {
51839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51840       };
51841     } catch (...) {
51842       {
51843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51844       };
51845     }
51846   }
51847
51848   jresult = (void *)result;
51849   return jresult;
51850 }
51851
51852
51853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51854   void * jresult ;
51855   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51856   Dali::Vector< float >::Iterator result;
51857
51858   arg1 = (Dali::Vector< float > *)jarg1;
51859   {
51860     try {
51861       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51862     } catch (std::out_of_range& e) {
51863       {
51864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51865       };
51866     } catch (std::exception& e) {
51867       {
51868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51869       };
51870     } catch (Dali::DaliException e) {
51871       {
51872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51873       };
51874     } catch (...) {
51875       {
51876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51877       };
51878     }
51879   }
51880
51881   jresult = (void *)result;
51882   return jresult;
51883 }
51884
51885
51886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51887   void * jresult ;
51888   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51889   Dali::Vector< float >::Iterator result;
51890
51891   arg1 = (Dali::Vector< float > *)jarg1;
51892   {
51893     try {
51894       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51895     } catch (std::out_of_range& e) {
51896       {
51897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51898       };
51899     } catch (std::exception& e) {
51900       {
51901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51902       };
51903     } catch (Dali::DaliException e) {
51904       {
51905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51906       };
51907     } catch (...) {
51908       {
51909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51910       };
51911     }
51912   }
51913
51914   jresult = (void *)result;
51915   return jresult;
51916 }
51917
51918
51919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51920   void * jresult ;
51921   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51922   Dali::Vector< float >::SizeType arg2 ;
51923   Dali::Vector< float >::ItemType *result = 0 ;
51924
51925   arg1 = (Dali::Vector< float > *)jarg1;
51926   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51927   {
51928     try {
51929       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51930     } catch (std::out_of_range& e) {
51931       {
51932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51933       };
51934     } catch (std::exception& e) {
51935       {
51936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51937       };
51938     } catch (Dali::DaliException e) {
51939       {
51940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51941       };
51942     } catch (...) {
51943       {
51944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51945       };
51946     }
51947   }
51948
51949   jresult = (void *)result;
51950   return jresult;
51951 }
51952
51953
51954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51955   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51956   Dali::Vector< float >::ItemType *arg2 = 0 ;
51957   Dali::Vector< float >::ItemType temp2 ;
51958
51959   arg1 = (Dali::Vector< float > *)jarg1;
51960   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51961   arg2 = &temp2;
51962   {
51963     try {
51964       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51965     } catch (std::out_of_range& e) {
51966       {
51967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51968       };
51969     } catch (std::exception& e) {
51970       {
51971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51972       };
51973     } catch (Dali::DaliException e) {
51974       {
51975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51976       };
51977     } catch (...) {
51978       {
51979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51980       };
51981     }
51982   }
51983
51984 }
51985
51986
51987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51988   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51989   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51990   Dali::Vector< float >::ItemType *arg3 = 0 ;
51991   Dali::Vector< float >::ItemType temp3 ;
51992
51993   arg1 = (Dali::Vector< float > *)jarg1;
51994   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51995   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51996   arg3 = &temp3;
51997   {
51998     try {
51999       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52000     } catch (std::out_of_range& e) {
52001       {
52002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52003       };
52004     } catch (std::exception& e) {
52005       {
52006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52007       };
52008     } catch (Dali::DaliException e) {
52009       {
52010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52011       };
52012     } catch (...) {
52013       {
52014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52015       };
52016     }
52017   }
52018
52019 }
52020
52021
52022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52023   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52024   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52025   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52026   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52027
52028   arg1 = (Dali::Vector< float > *)jarg1;
52029   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52030   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52031   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52032   {
52033     try {
52034       (arg1)->Insert(arg2,arg3,arg4);
52035     } catch (std::out_of_range& e) {
52036       {
52037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52038       };
52039     } catch (std::exception& e) {
52040       {
52041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52042       };
52043     } catch (Dali::DaliException e) {
52044       {
52045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52046       };
52047     } catch (...) {
52048       {
52049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52050       };
52051     }
52052   }
52053
52054 }
52055
52056
52057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52058   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52059   Dali::Vector< float >::SizeType arg2 ;
52060
52061   arg1 = (Dali::Vector< float > *)jarg1;
52062   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52063   {
52064     try {
52065       (arg1)->Reserve(arg2);
52066     } catch (std::out_of_range& e) {
52067       {
52068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52069       };
52070     } catch (std::exception& e) {
52071       {
52072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52073       };
52074     } catch (Dali::DaliException e) {
52075       {
52076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52077       };
52078     } catch (...) {
52079       {
52080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52081       };
52082     }
52083   }
52084
52085 }
52086
52087 //// ========================= end of part 2 =============================
52088
52089 //// ========================== start part 3 ===============================
52090
52091
52092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52093   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52094   Dali::Vector< float >::SizeType arg2 ;
52095
52096   arg1 = (Dali::Vector< float > *)jarg1;
52097   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52098   {
52099     try {
52100       (arg1)->Resize(arg2);
52101     } catch (std::out_of_range& e) {
52102       {
52103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52104       };
52105     } catch (std::exception& e) {
52106       {
52107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52108       };
52109     } catch (Dali::DaliException e) {
52110       {
52111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52112       };
52113     } catch (...) {
52114       {
52115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52116       };
52117     }
52118   }
52119
52120 }
52121
52122
52123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52124   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52125   Dali::Vector< float >::SizeType arg2 ;
52126   Dali::Vector< float >::ItemType *arg3 = 0 ;
52127   Dali::Vector< float >::ItemType temp3 ;
52128
52129   arg1 = (Dali::Vector< float > *)jarg1;
52130   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52131   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52132   arg3 = &temp3;
52133   {
52134     try {
52135       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52136     } catch (std::out_of_range& e) {
52137       {
52138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52139       };
52140     } catch (std::exception& e) {
52141       {
52142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52143       };
52144     } catch (Dali::DaliException e) {
52145       {
52146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52147       };
52148     } catch (...) {
52149       {
52150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52151       };
52152     }
52153   }
52154
52155 }
52156
52157
52158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52159   void * jresult ;
52160   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52161   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52162   Dali::Vector< float >::Iterator result;
52163
52164   arg1 = (Dali::Vector< float > *)jarg1;
52165   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52166   {
52167     try {
52168       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52169     } catch (std::out_of_range& e) {
52170       {
52171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52172       };
52173     } catch (std::exception& e) {
52174       {
52175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52176       };
52177     } catch (Dali::DaliException e) {
52178       {
52179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52180       };
52181     } catch (...) {
52182       {
52183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52184       };
52185     }
52186   }
52187
52188   jresult = (void *)result;
52189   return jresult;
52190 }
52191
52192
52193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52194   void * jresult ;
52195   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52196   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52197   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52198   Dali::Vector< float >::Iterator result;
52199
52200   arg1 = (Dali::Vector< float > *)jarg1;
52201   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52202   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52203   {
52204     try {
52205       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52206     } catch (std::out_of_range& e) {
52207       {
52208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52209       };
52210     } catch (std::exception& e) {
52211       {
52212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52213       };
52214     } catch (Dali::DaliException e) {
52215       {
52216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52217       };
52218     } catch (...) {
52219       {
52220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52221       };
52222     }
52223   }
52224
52225   jresult = (void *)result;
52226   return jresult;
52227 }
52228
52229
52230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52231   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52232   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52233
52234   arg1 = (Dali::Vector< float > *)jarg1;
52235   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52236   {
52237     try {
52238       (arg1)->Remove(arg2);
52239     } catch (std::out_of_range& e) {
52240       {
52241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52242       };
52243     } catch (std::exception& e) {
52244       {
52245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52246       };
52247     } catch (Dali::DaliException e) {
52248       {
52249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52250       };
52251     } catch (...) {
52252       {
52253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52254       };
52255     }
52256   }
52257
52258 }
52259
52260
52261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52262   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52263   Dali::Vector< float > *arg2 = 0 ;
52264
52265   arg1 = (Dali::Vector< float > *)jarg1;
52266   arg2 = (Dali::Vector< float > *)jarg2;
52267   if (!arg2) {
52268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52269     return ;
52270   }
52271   {
52272     try {
52273       (arg1)->Swap(*arg2);
52274     } catch (std::out_of_range& e) {
52275       {
52276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52277       };
52278     } catch (std::exception& e) {
52279       {
52280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52281       };
52282     } catch (Dali::DaliException e) {
52283       {
52284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52285       };
52286     } catch (...) {
52287       {
52288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52289       };
52290     }
52291   }
52292
52293 }
52294
52295
52296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52297   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52298
52299   arg1 = (Dali::Vector< float > *)jarg1;
52300   {
52301     try {
52302       (arg1)->Clear();
52303     } catch (std::out_of_range& e) {
52304       {
52305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52306       };
52307     } catch (std::exception& e) {
52308       {
52309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52310       };
52311     } catch (Dali::DaliException e) {
52312       {
52313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52314       };
52315     } catch (...) {
52316       {
52317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52318       };
52319     }
52320   }
52321
52322 }
52323
52324
52325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52326   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52327
52328   arg1 = (Dali::Vector< float > *)jarg1;
52329   {
52330     try {
52331       (arg1)->Release();
52332     } catch (std::out_of_range& e) {
52333       {
52334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52335       };
52336     } catch (std::exception& e) {
52337       {
52338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52339       };
52340     } catch (Dali::DaliException e) {
52341       {
52342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52343       };
52344     } catch (...) {
52345       {
52346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52347       };
52348     }
52349   }
52350
52351 }
52352
52353
52354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52355   int jresult ;
52356   int result;
52357
52358   result = (int)Dali::Vector< unsigned char >::BaseType;
52359   jresult = (int)result;
52360   return jresult;
52361 }
52362
52363
52364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52365   void * jresult ;
52366   Dali::Vector< unsigned char > *result = 0 ;
52367
52368   {
52369     try {
52370       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52371     } catch (std::out_of_range& e) {
52372       {
52373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52374       };
52375     } catch (std::exception& e) {
52376       {
52377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52378       };
52379     } catch (Dali::DaliException e) {
52380       {
52381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52382       };
52383     } catch (...) {
52384       {
52385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52386       };
52387     }
52388   }
52389
52390   jresult = (void *)result;
52391   return jresult;
52392 }
52393
52394
52395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52396   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52397
52398   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52399   {
52400     try {
52401       delete arg1;
52402     } catch (std::out_of_range& e) {
52403       {
52404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52405       };
52406     } catch (std::exception& e) {
52407       {
52408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52409       };
52410     } catch (Dali::DaliException e) {
52411       {
52412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52413       };
52414     } catch (...) {
52415       {
52416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52417       };
52418     }
52419   }
52420
52421 }
52422
52423
52424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52425   void * jresult ;
52426   Dali::Vector< unsigned char > *arg1 = 0 ;
52427   Dali::Vector< unsigned char > *result = 0 ;
52428
52429   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52430   if (!arg1) {
52431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52432     return 0;
52433   }
52434   {
52435     try {
52436       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52437     } catch (std::out_of_range& e) {
52438       {
52439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52440       };
52441     } catch (std::exception& e) {
52442       {
52443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52444       };
52445     } catch (Dali::DaliException e) {
52446       {
52447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52448       };
52449     } catch (...) {
52450       {
52451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52452       };
52453     }
52454   }
52455
52456   jresult = (void *)result;
52457   return jresult;
52458 }
52459
52460
52461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52462   void * jresult ;
52463   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52464   Dali::Vector< unsigned char > *arg2 = 0 ;
52465   Dali::Vector< unsigned char > *result = 0 ;
52466
52467   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52468   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52469   if (!arg2) {
52470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52471     return 0;
52472   }
52473   {
52474     try {
52475       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52476     } catch (std::out_of_range& e) {
52477       {
52478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52479       };
52480     } catch (std::exception& e) {
52481       {
52482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52483       };
52484     } catch (Dali::DaliException e) {
52485       {
52486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52487       };
52488     } catch (...) {
52489       {
52490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52491       };
52492     }
52493   }
52494
52495   jresult = (void *)result;
52496   return jresult;
52497 }
52498
52499
52500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52501   void * jresult ;
52502   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52503   Dali::Vector< unsigned char >::Iterator result;
52504
52505   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52506   {
52507     try {
52508       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52509     } catch (std::out_of_range& e) {
52510       {
52511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52512       };
52513     } catch (std::exception& e) {
52514       {
52515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52516       };
52517     } catch (Dali::DaliException e) {
52518       {
52519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52520       };
52521     } catch (...) {
52522       {
52523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52524       };
52525     }
52526   }
52527
52528   jresult = (void *)result;
52529   return jresult;
52530 }
52531
52532
52533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52534   void * jresult ;
52535   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52536   Dali::Vector< unsigned char >::Iterator result;
52537
52538   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52539   {
52540     try {
52541       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52542     } catch (std::out_of_range& e) {
52543       {
52544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52545       };
52546     } catch (std::exception& e) {
52547       {
52548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52549       };
52550     } catch (Dali::DaliException e) {
52551       {
52552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52553       };
52554     } catch (...) {
52555       {
52556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52557       };
52558     }
52559   }
52560
52561   jresult = (void *)result;
52562   return jresult;
52563 }
52564
52565
52566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52567   void * jresult ;
52568   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52569   Dali::Vector< unsigned char >::SizeType arg2 ;
52570   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52571
52572   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52573   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52574   {
52575     try {
52576       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52577     } catch (std::out_of_range& e) {
52578       {
52579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52580       };
52581     } catch (std::exception& e) {
52582       {
52583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52584       };
52585     } catch (Dali::DaliException e) {
52586       {
52587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52588       };
52589     } catch (...) {
52590       {
52591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52592       };
52593     }
52594   }
52595
52596   jresult = (void *)result;
52597   return jresult;
52598 }
52599
52600
52601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52602   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52603   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52604   Dali::Vector< unsigned char >::ItemType temp2 ;
52605
52606   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52607   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52608   arg2 = &temp2;
52609   {
52610     try {
52611       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52612     } catch (std::out_of_range& e) {
52613       {
52614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52615       };
52616     } catch (std::exception& e) {
52617       {
52618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52619       };
52620     } catch (Dali::DaliException e) {
52621       {
52622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52623       };
52624     } catch (...) {
52625       {
52626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52627       };
52628     }
52629   }
52630
52631 }
52632
52633
52634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52635   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52636   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52637   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52638   Dali::Vector< unsigned char >::ItemType temp3 ;
52639
52640   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52641   arg2 = jarg2;
52642   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52643   arg3 = &temp3;
52644   {
52645     try {
52646       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52647     } catch (std::out_of_range& e) {
52648       {
52649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52650       };
52651     } catch (std::exception& e) {
52652       {
52653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52654       };
52655     } catch (Dali::DaliException e) {
52656       {
52657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52658       };
52659     } catch (...) {
52660       {
52661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52662       };
52663     }
52664   }
52665
52666
52667
52668 }
52669
52670
52671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52672   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52673   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52674   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52675   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52676
52677   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52678   arg2 = jarg2;
52679   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52680   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52681   {
52682     try {
52683       (arg1)->Insert(arg2,arg3,arg4);
52684     } catch (std::out_of_range& e) {
52685       {
52686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52687       };
52688     } catch (std::exception& e) {
52689       {
52690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52691       };
52692     } catch (Dali::DaliException e) {
52693       {
52694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52695       };
52696     } catch (...) {
52697       {
52698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52699       };
52700     }
52701   }
52702
52703
52704
52705 }
52706
52707
52708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52709   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52710   Dali::Vector< unsigned char >::SizeType arg2 ;
52711
52712   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52713   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52714   {
52715     try {
52716       (arg1)->Reserve(arg2);
52717     } catch (std::out_of_range& e) {
52718       {
52719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52720       };
52721     } catch (std::exception& e) {
52722       {
52723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52724       };
52725     } catch (Dali::DaliException e) {
52726       {
52727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52728       };
52729     } catch (...) {
52730       {
52731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52732       };
52733     }
52734   }
52735
52736 }
52737
52738
52739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52740   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52741   Dali::Vector< unsigned char >::SizeType arg2 ;
52742
52743   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52744   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52745   {
52746     try {
52747       (arg1)->Resize(arg2);
52748     } catch (std::out_of_range& e) {
52749       {
52750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52751       };
52752     } catch (std::exception& e) {
52753       {
52754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52755       };
52756     } catch (Dali::DaliException e) {
52757       {
52758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52759       };
52760     } catch (...) {
52761       {
52762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52763       };
52764     }
52765   }
52766
52767 }
52768
52769
52770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52771   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52772   Dali::Vector< unsigned char >::SizeType arg2 ;
52773   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52774   Dali::Vector< unsigned char >::ItemType temp3 ;
52775
52776   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52777   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52778   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52779   arg3 = &temp3;
52780   {
52781     try {
52782       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52783     } catch (std::out_of_range& e) {
52784       {
52785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52786       };
52787     } catch (std::exception& e) {
52788       {
52789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52790       };
52791     } catch (Dali::DaliException e) {
52792       {
52793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52794       };
52795     } catch (...) {
52796       {
52797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52798       };
52799     }
52800   }
52801
52802 }
52803
52804
52805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52806   void * jresult ;
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   Dali::Vector< unsigned char >::Iterator result;
52810
52811   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52812   arg2 = jarg2;
52813   {
52814     try {
52815       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52816     } catch (std::out_of_range& e) {
52817       {
52818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52819       };
52820     } catch (std::exception& e) {
52821       {
52822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52823       };
52824     } catch (Dali::DaliException e) {
52825       {
52826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52827       };
52828     } catch (...) {
52829       {
52830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52831       };
52832     }
52833   }
52834
52835   jresult = (void *)result;
52836
52837
52838   return jresult;
52839 }
52840
52841
52842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52843   void * jresult ;
52844   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52845   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52846   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52847   Dali::Vector< unsigned char >::Iterator result;
52848
52849   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52850   arg2 = jarg2;
52851   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52852   {
52853     try {
52854       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52855     } catch (std::out_of_range& e) {
52856       {
52857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52858       };
52859     } catch (std::exception& e) {
52860       {
52861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52862       };
52863     } catch (Dali::DaliException e) {
52864       {
52865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52866       };
52867     } catch (...) {
52868       {
52869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52870       };
52871     }
52872   }
52873
52874   jresult = (void *)result;
52875
52876
52877   return jresult;
52878 }
52879
52880
52881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52882   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52883   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52884
52885   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52886   arg2 = jarg2;
52887   {
52888     try {
52889       (arg1)->Remove(arg2);
52890     } catch (std::out_of_range& e) {
52891       {
52892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52893       };
52894     } catch (std::exception& e) {
52895       {
52896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52897       };
52898     } catch (Dali::DaliException e) {
52899       {
52900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52901       };
52902     } catch (...) {
52903       {
52904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52905       };
52906     }
52907   }
52908
52909
52910
52911 }
52912
52913
52914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52915   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52916   Dali::Vector< unsigned char > *arg2 = 0 ;
52917
52918   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52919   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52920   if (!arg2) {
52921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52922     return ;
52923   }
52924   {
52925     try {
52926       (arg1)->Swap(*arg2);
52927     } catch (std::out_of_range& e) {
52928       {
52929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52930       };
52931     } catch (std::exception& e) {
52932       {
52933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52934       };
52935     } catch (Dali::DaliException e) {
52936       {
52937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52938       };
52939     } catch (...) {
52940       {
52941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52942       };
52943     }
52944   }
52945
52946 }
52947
52948
52949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52950   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52951
52952   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52953   {
52954     try {
52955       (arg1)->Clear();
52956     } catch (std::out_of_range& e) {
52957       {
52958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52959       };
52960     } catch (std::exception& e) {
52961       {
52962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52963       };
52964     } catch (Dali::DaliException e) {
52965       {
52966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52967       };
52968     } catch (...) {
52969       {
52970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52971       };
52972     }
52973   }
52974
52975 }
52976
52977
52978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52979   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52980
52981   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52982   {
52983     try {
52984       (arg1)->Release();
52985     } catch (std::out_of_range& e) {
52986       {
52987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52988       };
52989     } catch (std::exception& e) {
52990       {
52991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52992       };
52993     } catch (Dali::DaliException e) {
52994       {
52995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52996       };
52997     } catch (...) {
52998       {
52999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53000       };
53001     }
53002   }
53003
53004 }
53005
53006
53007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53008   int jresult ;
53009   int result;
53010
53011   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53012   jresult = (int)result;
53013   return jresult;
53014 }
53015
53016
53017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53018   void * jresult ;
53019   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53020
53021   {
53022     try {
53023       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53024     } catch (std::out_of_range& e) {
53025       {
53026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53027       };
53028     } catch (std::exception& e) {
53029       {
53030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53031       };
53032     } catch (Dali::DaliException e) {
53033       {
53034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53035       };
53036     } catch (...) {
53037       {
53038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53039       };
53040     }
53041   }
53042
53043   jresult = (void *)result;
53044   return jresult;
53045 }
53046
53047
53048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53049   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53050
53051   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53052   {
53053     try {
53054       delete arg1;
53055     } catch (std::out_of_range& e) {
53056       {
53057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53058       };
53059     } catch (std::exception& e) {
53060       {
53061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53062       };
53063     } catch (Dali::DaliException e) {
53064       {
53065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53066       };
53067     } catch (...) {
53068       {
53069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53070       };
53071     }
53072   }
53073
53074 }
53075
53076
53077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53078   void * jresult ;
53079   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53080   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53081
53082   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53083   if (!arg1) {
53084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53085     return 0;
53086   }
53087   {
53088     try {
53089       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53090     } catch (std::out_of_range& e) {
53091       {
53092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53093       };
53094     } catch (std::exception& e) {
53095       {
53096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53097       };
53098     } catch (Dali::DaliException e) {
53099       {
53100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53101       };
53102     } catch (...) {
53103       {
53104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53105       };
53106     }
53107   }
53108
53109   jresult = (void *)result;
53110   return jresult;
53111 }
53112
53113
53114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53115   void * jresult ;
53116   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53117   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53118   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53119
53120   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53121   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53122   if (!arg2) {
53123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53124     return 0;
53125   }
53126   {
53127     try {
53128       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53129     } catch (std::out_of_range& e) {
53130       {
53131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53132       };
53133     } catch (std::exception& e) {
53134       {
53135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53136       };
53137     } catch (Dali::DaliException e) {
53138       {
53139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53140       };
53141     } catch (...) {
53142       {
53143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53144       };
53145     }
53146   }
53147
53148   jresult = (void *)result;
53149   return jresult;
53150 }
53151
53152
53153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53154   void * jresult ;
53155   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53156   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53157
53158   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53159   {
53160     try {
53161       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53162     } catch (std::out_of_range& e) {
53163       {
53164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53165       };
53166     } catch (std::exception& e) {
53167       {
53168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53169       };
53170     } catch (Dali::DaliException e) {
53171       {
53172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53173       };
53174     } catch (...) {
53175       {
53176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53177       };
53178     }
53179   }
53180
53181   jresult = (void *)result;
53182   return jresult;
53183 }
53184
53185
53186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53187   void * jresult ;
53188   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53189   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53190
53191   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53192   {
53193     try {
53194       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53195     } catch (std::out_of_range& e) {
53196       {
53197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53198       };
53199     } catch (std::exception& e) {
53200       {
53201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53202       };
53203     } catch (Dali::DaliException e) {
53204       {
53205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53206       };
53207     } catch (...) {
53208       {
53209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53210       };
53211     }
53212   }
53213
53214   jresult = (void *)result;
53215   return jresult;
53216 }
53217
53218
53219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53220   void * jresult ;
53221   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53222   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53223   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53224
53225   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53226   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53227   {
53228     try {
53229       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53230     } catch (std::out_of_range& e) {
53231       {
53232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53233       };
53234     } catch (std::exception& e) {
53235       {
53236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53237       };
53238     } catch (Dali::DaliException e) {
53239       {
53240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53241       };
53242     } catch (...) {
53243       {
53244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53245       };
53246     }
53247   }
53248
53249   jresult = (void *)result;
53250   return jresult;
53251 }
53252
53253
53254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53255   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53256   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53257
53258   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53259   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53260   if (!arg2) {
53261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53262     return ;
53263   }
53264   {
53265     try {
53266       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53267     } catch (std::out_of_range& e) {
53268       {
53269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53270       };
53271     } catch (std::exception& e) {
53272       {
53273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53274       };
53275     } catch (Dali::DaliException e) {
53276       {
53277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53278       };
53279     } catch (...) {
53280       {
53281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53282       };
53283     }
53284   }
53285
53286 }
53287
53288
53289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53290   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53291   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53292   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53293
53294   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53295   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53296   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53297   if (!arg3) {
53298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53299     return ;
53300   }
53301   {
53302     try {
53303       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53304     } catch (std::out_of_range& e) {
53305       {
53306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53307       };
53308     } catch (std::exception& e) {
53309       {
53310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53311       };
53312     } catch (Dali::DaliException e) {
53313       {
53314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53315       };
53316     } catch (...) {
53317       {
53318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53319       };
53320     }
53321   }
53322
53323 }
53324
53325
53326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53327   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53328   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53329   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53330   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53331
53332   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53333   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53334   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53335   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53336   {
53337     try {
53338       (arg1)->Insert(arg2,arg3,arg4);
53339     } catch (std::out_of_range& e) {
53340       {
53341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53342       };
53343     } catch (std::exception& e) {
53344       {
53345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53346       };
53347     } catch (Dali::DaliException e) {
53348       {
53349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53350       };
53351     } catch (...) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53354       };
53355     }
53356   }
53357
53358 }
53359
53360
53361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53362   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53363   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53364
53365   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53366   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53367   {
53368     try {
53369       (arg1)->Reserve(arg2);
53370     } catch (std::out_of_range& e) {
53371       {
53372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53373       };
53374     } catch (std::exception& e) {
53375       {
53376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53377       };
53378     } catch (Dali::DaliException e) {
53379       {
53380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53381       };
53382     } catch (...) {
53383       {
53384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53385       };
53386     }
53387   }
53388
53389 }
53390
53391
53392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53393   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53394   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53395
53396   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53397   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53398   {
53399     try {
53400       (arg1)->Resize(arg2);
53401     } catch (std::out_of_range& e) {
53402       {
53403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53404       };
53405     } catch (std::exception& e) {
53406       {
53407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53408       };
53409     } catch (Dali::DaliException e) {
53410       {
53411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53412       };
53413     } catch (...) {
53414       {
53415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53416       };
53417     }
53418   }
53419
53420 }
53421
53422
53423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53424   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53425   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53426   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53427
53428   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53429   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53430   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53431   if (!arg3) {
53432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53433     return ;
53434   }
53435   {
53436     try {
53437       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53438     } catch (std::out_of_range& e) {
53439       {
53440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53441       };
53442     } catch (std::exception& e) {
53443       {
53444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53445       };
53446     } catch (Dali::DaliException e) {
53447       {
53448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53449       };
53450     } catch (...) {
53451       {
53452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53453       };
53454     }
53455   }
53456
53457 }
53458
53459
53460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53461   void * jresult ;
53462   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53463   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53464   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53465
53466   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53467   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53468   {
53469     try {
53470       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53471     } catch (std::out_of_range& e) {
53472       {
53473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53474       };
53475     } catch (std::exception& e) {
53476       {
53477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53478       };
53479     } catch (Dali::DaliException e) {
53480       {
53481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53482       };
53483     } catch (...) {
53484       {
53485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53486       };
53487     }
53488   }
53489
53490   jresult = (void *)result;
53491   return jresult;
53492 }
53493
53494
53495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53496   void * jresult ;
53497   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53498   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53499   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53500   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53501
53502   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53503   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53504   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53505   {
53506     try {
53507       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53508     } catch (std::out_of_range& e) {
53509       {
53510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53511       };
53512     } catch (std::exception& e) {
53513       {
53514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53515       };
53516     } catch (Dali::DaliException e) {
53517       {
53518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53519       };
53520     } catch (...) {
53521       {
53522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53523       };
53524     }
53525   }
53526
53527   jresult = (void *)result;
53528   return jresult;
53529 }
53530
53531
53532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53533   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53534   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53535
53536   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53537   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53538   {
53539     try {
53540       (arg1)->Remove(arg2);
53541     } catch (std::out_of_range& e) {
53542       {
53543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53544       };
53545     } catch (std::exception& e) {
53546       {
53547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53548       };
53549     } catch (Dali::DaliException e) {
53550       {
53551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53552       };
53553     } catch (...) {
53554       {
53555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53556       };
53557     }
53558   }
53559
53560 }
53561
53562
53563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53564   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53565   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53566
53567   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53568   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53569   if (!arg2) {
53570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53571     return ;
53572   }
53573   {
53574     try {
53575       (arg1)->Swap(*arg2);
53576     } catch (std::out_of_range& e) {
53577       {
53578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53579       };
53580     } catch (std::exception& e) {
53581       {
53582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53583       };
53584     } catch (Dali::DaliException e) {
53585       {
53586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53587       };
53588     } catch (...) {
53589       {
53590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53591       };
53592     }
53593   }
53594
53595 }
53596
53597
53598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53599   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53600
53601   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53602   {
53603     try {
53604       (arg1)->Clear();
53605     } catch (std::out_of_range& e) {
53606       {
53607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53608       };
53609     } catch (std::exception& e) {
53610       {
53611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53612       };
53613     } catch (Dali::DaliException e) {
53614       {
53615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53616       };
53617     } catch (...) {
53618       {
53619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53620       };
53621     }
53622   }
53623
53624 }
53625
53626
53627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53628   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53629
53630   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53631   {
53632     try {
53633       (arg1)->Release();
53634     } catch (std::out_of_range& e) {
53635       {
53636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53637       };
53638     } catch (std::exception& e) {
53639       {
53640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53641       };
53642     } catch (Dali::DaliException e) {
53643       {
53644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53645       };
53646     } catch (...) {
53647       {
53648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53649       };
53650     }
53651   }
53652
53653 }
53654
53655
53656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53657   void * jresult ;
53658   Dali::Signal< void () > *result = 0 ;
53659
53660   {
53661     try {
53662       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53663     } catch (std::out_of_range& e) {
53664       {
53665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53666       };
53667     } catch (std::exception& e) {
53668       {
53669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53670       };
53671     } catch (Dali::DaliException e) {
53672       {
53673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53674       };
53675     } catch (...) {
53676       {
53677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53678       };
53679     }
53680   }
53681
53682   jresult = (void *)result;
53683   return jresult;
53684 }
53685
53686
53687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53688   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53689
53690   arg1 = (Dali::Signal< void () > *)jarg1;
53691   {
53692     try {
53693       delete arg1;
53694     } catch (std::out_of_range& e) {
53695       {
53696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53697       };
53698     } catch (std::exception& e) {
53699       {
53700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53701       };
53702     } catch (Dali::DaliException e) {
53703       {
53704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53705       };
53706     } catch (...) {
53707       {
53708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53709       };
53710     }
53711   }
53712
53713 }
53714
53715
53716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53717   unsigned int jresult ;
53718   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53719   bool result;
53720
53721   arg1 = (Dali::Signal< void () > *)jarg1;
53722   {
53723     try {
53724       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53725     } catch (std::out_of_range& e) {
53726       {
53727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53728       };
53729     } catch (std::exception& e) {
53730       {
53731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53732       };
53733     } catch (Dali::DaliException e) {
53734       {
53735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53736       };
53737     } catch (...) {
53738       {
53739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53740       };
53741     }
53742   }
53743
53744   jresult = result;
53745   return jresult;
53746 }
53747
53748
53749 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53750   unsigned long jresult ;
53751   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53752   std::size_t result;
53753
53754   arg1 = (Dali::Signal< void () > *)jarg1;
53755   {
53756     try {
53757       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53758     } catch (std::out_of_range& e) {
53759       {
53760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53761       };
53762     } catch (std::exception& e) {
53763       {
53764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53765       };
53766     } catch (Dali::DaliException e) {
53767       {
53768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53769       };
53770     } catch (...) {
53771       {
53772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53773       };
53774     }
53775   }
53776
53777   jresult = (unsigned long)result;
53778   return jresult;
53779 }
53780
53781
53782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53783   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53784   void (*arg2)() = (void (*)()) 0 ;
53785
53786   arg1 = (Dali::Signal< void () > *)jarg1;
53787   arg2 = (void (*)())jarg2;
53788   {
53789     try {
53790       (arg1)->Connect(arg2);
53791     } catch (std::out_of_range& e) {
53792       {
53793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53794       };
53795     } catch (std::exception& e) {
53796       {
53797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53798       };
53799     } catch (Dali::DaliException e) {
53800       {
53801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53802       };
53803     } catch (...) {
53804       {
53805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53806       };
53807     }
53808   }
53809
53810 }
53811
53812
53813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53814   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53815   void (*arg2)() = (void (*)()) 0 ;
53816
53817   arg1 = (Dali::Signal< void () > *)jarg1;
53818   arg2 = (void (*)())jarg2;
53819   {
53820     try {
53821       (arg1)->Disconnect(arg2);
53822     } catch (std::out_of_range& e) {
53823       {
53824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53825       };
53826     } catch (std::exception& e) {
53827       {
53828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53829       };
53830     } catch (Dali::DaliException e) {
53831       {
53832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53833       };
53834     } catch (...) {
53835       {
53836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53837       };
53838     }
53839   }
53840
53841 }
53842
53843
53844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53845   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53846   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53847   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53848
53849   arg1 = (Dali::Signal< void () > *)jarg1;
53850   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53851   arg3 = (Dali::FunctorDelegate *)jarg3;
53852   {
53853     try {
53854       (arg1)->Connect(arg2,arg3);
53855     } catch (std::out_of_range& e) {
53856       {
53857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53858       };
53859     } catch (std::exception& e) {
53860       {
53861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53862       };
53863     } catch (Dali::DaliException e) {
53864       {
53865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53866       };
53867     } catch (...) {
53868       {
53869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53870       };
53871     }
53872   }
53873
53874 }
53875
53876
53877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53878   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53879
53880   arg1 = (Dali::Signal< void () > *)jarg1;
53881   {
53882     try {
53883       (arg1)->Emit();
53884     } catch (std::out_of_range& e) {
53885       {
53886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53887       };
53888     } catch (std::exception& e) {
53889       {
53890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53891       };
53892     } catch (Dali::DaliException e) {
53893       {
53894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53895       };
53896     } catch (...) {
53897       {
53898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53899       };
53900     }
53901   }
53902
53903 }
53904
53905
53906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53907   unsigned int jresult ;
53908   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53909   bool result;
53910
53911   arg1 = (Dali::Signal< void (float) > *)jarg1;
53912   {
53913     try {
53914       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53915     } catch (std::out_of_range& e) {
53916       {
53917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53918       };
53919     } catch (std::exception& e) {
53920       {
53921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53922       };
53923     } catch (Dali::DaliException e) {
53924       {
53925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53926       };
53927     } catch (...) {
53928       {
53929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53930       };
53931     }
53932   }
53933
53934   jresult = result;
53935   return jresult;
53936 }
53937
53938
53939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53940   unsigned long jresult ;
53941   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53942   std::size_t result;
53943
53944   arg1 = (Dali::Signal< void (float) > *)jarg1;
53945   {
53946     try {
53947       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53948     } catch (std::out_of_range& e) {
53949       {
53950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53951       };
53952     } catch (std::exception& e) {
53953       {
53954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53955       };
53956     } catch (Dali::DaliException e) {
53957       {
53958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53959       };
53960     } catch (...) {
53961       {
53962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53963       };
53964     }
53965   }
53966
53967   jresult = (unsigned long)result;
53968   return jresult;
53969 }
53970
53971
53972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53973   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53974   void (*arg2)(float) = (void (*)(float)) 0 ;
53975
53976   arg1 = (Dali::Signal< void (float) > *)jarg1;
53977   arg2 = (void (*)(float))jarg2;
53978   {
53979     try {
53980       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53981     } catch (std::out_of_range& e) {
53982       {
53983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53984       };
53985     } catch (std::exception& e) {
53986       {
53987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53988       };
53989     } catch (Dali::DaliException e) {
53990       {
53991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53992       };
53993     } catch (...) {
53994       {
53995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53996       };
53997     }
53998   }
53999
54000 }
54001
54002
54003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54004   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54005   void (*arg2)(float) = (void (*)(float)) 0 ;
54006
54007   arg1 = (Dali::Signal< void (float) > *)jarg1;
54008   arg2 = (void (*)(float))jarg2;
54009   {
54010     try {
54011       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54012     } catch (std::out_of_range& e) {
54013       {
54014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54015       };
54016     } catch (std::exception& e) {
54017       {
54018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54019       };
54020     } catch (Dali::DaliException e) {
54021       {
54022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54023       };
54024     } catch (...) {
54025       {
54026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54027       };
54028     }
54029   }
54030
54031 }
54032
54033
54034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54035   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54036   float arg2 ;
54037
54038   arg1 = (Dali::Signal< void (float) > *)jarg1;
54039   arg2 = (float)jarg2;
54040   {
54041     try {
54042       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54043     } catch (std::out_of_range& e) {
54044       {
54045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54046       };
54047     } catch (std::exception& e) {
54048       {
54049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54050       };
54051     } catch (Dali::DaliException e) {
54052       {
54053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54054       };
54055     } catch (...) {
54056       {
54057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54058       };
54059     }
54060   }
54061
54062 }
54063
54064
54065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54066   void * jresult ;
54067   Dali::Signal< void (float) > *result = 0 ;
54068
54069   {
54070     try {
54071       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54072     } catch (std::out_of_range& e) {
54073       {
54074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54075       };
54076     } catch (std::exception& e) {
54077       {
54078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54079       };
54080     } catch (Dali::DaliException e) {
54081       {
54082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54083       };
54084     } catch (...) {
54085       {
54086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54087       };
54088     }
54089   }
54090
54091   jresult = (void *)result;
54092   return jresult;
54093 }
54094
54095
54096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54097   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54098
54099   arg1 = (Dali::Signal< void (float) > *)jarg1;
54100   {
54101     try {
54102       delete arg1;
54103     } catch (std::out_of_range& e) {
54104       {
54105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54106       };
54107     } catch (std::exception& e) {
54108       {
54109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54110       };
54111     } catch (Dali::DaliException e) {
54112       {
54113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54114       };
54115     } catch (...) {
54116       {
54117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54118       };
54119     }
54120   }
54121
54122 }
54123
54124
54125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54126   unsigned int jresult ;
54127   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54128   bool result;
54129
54130   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54131   {
54132     try {
54133       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54134     } catch (std::out_of_range& e) {
54135       {
54136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54137       };
54138     } catch (std::exception& e) {
54139       {
54140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54141       };
54142     } catch (Dali::DaliException e) {
54143       {
54144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54145       };
54146     } catch (...) {
54147       {
54148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54149       };
54150     }
54151   }
54152
54153   jresult = result;
54154   return jresult;
54155 }
54156
54157
54158 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54159   unsigned long jresult ;
54160   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54161   std::size_t result;
54162
54163   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54164   {
54165     try {
54166       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54167     } catch (std::out_of_range& e) {
54168       {
54169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54170       };
54171     } catch (std::exception& e) {
54172       {
54173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54174       };
54175     } catch (Dali::DaliException e) {
54176       {
54177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54178       };
54179     } catch (...) {
54180       {
54181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54182       };
54183     }
54184   }
54185
54186   jresult = (unsigned long)result;
54187   return jresult;
54188 }
54189
54190
54191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54192   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54193   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54194
54195   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54196   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54197   {
54198     try {
54199       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54200     } catch (std::out_of_range& e) {
54201       {
54202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54203       };
54204     } catch (std::exception& e) {
54205       {
54206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54207       };
54208     } catch (Dali::DaliException e) {
54209       {
54210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54211       };
54212     } catch (...) {
54213       {
54214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54215       };
54216     }
54217   }
54218
54219 }
54220
54221
54222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54223   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54224   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54225
54226   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54227   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54228   {
54229     try {
54230       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54231     } catch (std::out_of_range& e) {
54232       {
54233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54234       };
54235     } catch (std::exception& e) {
54236       {
54237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54238       };
54239     } catch (Dali::DaliException e) {
54240       {
54241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54242       };
54243     } catch (...) {
54244       {
54245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54246       };
54247     }
54248   }
54249
54250 }
54251
54252
54253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54254   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54255   Dali::BaseHandle arg2 ;
54256   Dali::BaseHandle *argp2 ;
54257
54258   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54259   argp2 = (Dali::BaseHandle *)jarg2;
54260   if (!argp2) {
54261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54262     return ;
54263   }
54264   arg2 = *argp2;
54265   {
54266     try {
54267       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54268     } catch (std::out_of_range& e) {
54269       {
54270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54271       };
54272     } catch (std::exception& e) {
54273       {
54274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54275       };
54276     } catch (Dali::DaliException e) {
54277       {
54278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54279       };
54280     } catch (...) {
54281       {
54282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54283       };
54284     }
54285   }
54286
54287 }
54288
54289
54290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54291   void * jresult ;
54292   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54293
54294   {
54295     try {
54296       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54297     } catch (std::out_of_range& e) {
54298       {
54299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54300       };
54301     } catch (std::exception& e) {
54302       {
54303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54304       };
54305     } catch (Dali::DaliException e) {
54306       {
54307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54308       };
54309     } catch (...) {
54310       {
54311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54312       };
54313     }
54314   }
54315
54316   jresult = (void *)result;
54317   return jresult;
54318 }
54319
54320
54321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54322   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54323
54324   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54325   {
54326     try {
54327       delete arg1;
54328     } catch (std::out_of_range& e) {
54329       {
54330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54331       };
54332     } catch (std::exception& e) {
54333       {
54334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54335       };
54336     } catch (Dali::DaliException e) {
54337       {
54338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54339       };
54340     } catch (...) {
54341       {
54342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54343       };
54344     }
54345   }
54346
54347 }
54348
54349
54350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54351   unsigned int jresult ;
54352   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54353   bool result;
54354
54355   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54356   {
54357     try {
54358       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54359     } catch (std::out_of_range& e) {
54360       {
54361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54362       };
54363     } catch (std::exception& e) {
54364       {
54365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54366       };
54367     } catch (Dali::DaliException e) {
54368       {
54369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54370       };
54371     } catch (...) {
54372       {
54373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54374       };
54375     }
54376   }
54377
54378   jresult = result;
54379   return jresult;
54380 }
54381
54382
54383 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54384   unsigned long jresult ;
54385   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54386   std::size_t result;
54387
54388   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54389   {
54390     try {
54391       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54392     } catch (std::out_of_range& e) {
54393       {
54394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54395       };
54396     } catch (std::exception& e) {
54397       {
54398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54399       };
54400     } catch (Dali::DaliException e) {
54401       {
54402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54403       };
54404     } catch (...) {
54405       {
54406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54407       };
54408     }
54409   }
54410
54411   jresult = (unsigned long)result;
54412   return jresult;
54413 }
54414
54415
54416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54417   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54418   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54419
54420   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54421   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54422   {
54423     try {
54424       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54425     } catch (std::out_of_range& e) {
54426       {
54427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54428       };
54429     } catch (std::exception& e) {
54430       {
54431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54432       };
54433     } catch (Dali::DaliException e) {
54434       {
54435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54436       };
54437     } catch (...) {
54438       {
54439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54440       };
54441     }
54442   }
54443
54444 }
54445
54446
54447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54448   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54449   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54450
54451   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54452   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54453   {
54454     try {
54455       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54456     } catch (std::out_of_range& e) {
54457       {
54458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54459       };
54460     } catch (std::exception& e) {
54461       {
54462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54463       };
54464     } catch (Dali::DaliException e) {
54465       {
54466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54467       };
54468     } catch (...) {
54469       {
54470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54471       };
54472     }
54473   }
54474
54475 }
54476
54477
54478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54479   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54480   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54481
54482   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54483   arg2 = (Dali::RefObject *)jarg2;
54484   {
54485     try {
54486       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54487     } catch (std::out_of_range& e) {
54488       {
54489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54490       };
54491     } catch (std::exception& e) {
54492       {
54493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54494       };
54495     } catch (Dali::DaliException e) {
54496       {
54497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54498       };
54499     } catch (...) {
54500       {
54501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54502       };
54503     }
54504   }
54505
54506 }
54507
54508
54509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54510   void * jresult ;
54511   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54512
54513   {
54514     try {
54515       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54516     } catch (std::out_of_range& e) {
54517       {
54518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54519       };
54520     } catch (std::exception& e) {
54521       {
54522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54523       };
54524     } catch (Dali::DaliException e) {
54525       {
54526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54527       };
54528     } catch (...) {
54529       {
54530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54531       };
54532     }
54533   }
54534
54535   jresult = (void *)result;
54536   return jresult;
54537 }
54538
54539
54540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54541   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54542
54543   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54544   {
54545     try {
54546       delete arg1;
54547     } catch (std::out_of_range& e) {
54548       {
54549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54550       };
54551     } catch (std::exception& e) {
54552       {
54553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54554       };
54555     } catch (Dali::DaliException e) {
54556       {
54557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54558       };
54559     } catch (...) {
54560       {
54561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54562       };
54563     }
54564   }
54565
54566 }
54567
54568
54569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54570   unsigned int jresult ;
54571   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54572   bool result;
54573
54574   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54575   {
54576     try {
54577       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54578     } catch (std::out_of_range& e) {
54579       {
54580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54581       };
54582     } catch (std::exception& e) {
54583       {
54584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54585       };
54586     } catch (Dali::DaliException e) {
54587       {
54588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54589       };
54590     } catch (...) {
54591       {
54592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54593       };
54594     }
54595   }
54596
54597   jresult = result;
54598   return jresult;
54599 }
54600
54601
54602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54603   unsigned long jresult ;
54604   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54605   std::size_t result;
54606
54607   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54608   {
54609     try {
54610       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54611     } catch (std::out_of_range& e) {
54612       {
54613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54614       };
54615     } catch (std::exception& e) {
54616       {
54617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54618       };
54619     } catch (Dali::DaliException e) {
54620       {
54621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54622       };
54623     } catch (...) {
54624       {
54625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54626       };
54627     }
54628   }
54629
54630   jresult = (unsigned long)result;
54631   return jresult;
54632 }
54633
54634
54635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54636   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54637   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54638
54639   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54640   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54641   {
54642     try {
54643       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54644     } catch (std::out_of_range& e) {
54645       {
54646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54647       };
54648     } catch (std::exception& e) {
54649       {
54650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54651       };
54652     } catch (Dali::DaliException e) {
54653       {
54654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54655       };
54656     } catch (...) {
54657       {
54658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54659       };
54660     }
54661   }
54662
54663 }
54664
54665
54666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54667   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54668   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54669
54670   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54671   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54672   {
54673     try {
54674       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54675     } catch (std::out_of_range& e) {
54676       {
54677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54678       };
54679     } catch (std::exception& e) {
54680       {
54681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54682       };
54683     } catch (Dali::DaliException e) {
54684       {
54685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54686       };
54687     } catch (...) {
54688       {
54689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54690       };
54691     }
54692   }
54693
54694 }
54695
54696
54697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54698   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54699   Dali::PropertyNotification *arg2 = 0 ;
54700
54701   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54702   arg2 = (Dali::PropertyNotification *)jarg2;
54703   if (!arg2) {
54704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54705     return ;
54706   }
54707   {
54708     try {
54709       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54710     } catch (std::out_of_range& e) {
54711       {
54712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54713       };
54714     } catch (std::exception& e) {
54715       {
54716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54717       };
54718     } catch (Dali::DaliException e) {
54719       {
54720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54721       };
54722     } catch (...) {
54723       {
54724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54725       };
54726     }
54727   }
54728
54729 }
54730
54731
54732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54733   void * jresult ;
54734   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54735
54736   {
54737     try {
54738       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54739     } catch (std::out_of_range& e) {
54740       {
54741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54742       };
54743     } catch (std::exception& e) {
54744       {
54745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54746       };
54747     } catch (Dali::DaliException e) {
54748       {
54749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54750       };
54751     } catch (...) {
54752       {
54753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54754       };
54755     }
54756   }
54757
54758   jresult = (void *)result;
54759   return jresult;
54760 }
54761
54762
54763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54764   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54765
54766   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54767   {
54768     try {
54769       delete arg1;
54770     } catch (std::out_of_range& e) {
54771       {
54772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54773       };
54774     } catch (std::exception& e) {
54775       {
54776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54777       };
54778     } catch (Dali::DaliException e) {
54779       {
54780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54781       };
54782     } catch (...) {
54783       {
54784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54785       };
54786     }
54787   }
54788
54789 }
54790
54791
54792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54793   unsigned int jresult ;
54794   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54795   bool result;
54796
54797   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54798   {
54799     try {
54800       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54801     } catch (std::out_of_range& e) {
54802       {
54803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54804       };
54805     } catch (std::exception& e) {
54806       {
54807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54808       };
54809     } catch (Dali::DaliException e) {
54810       {
54811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54812       };
54813     } catch (...) {
54814       {
54815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54816       };
54817     }
54818   }
54819
54820   jresult = result;
54821   return jresult;
54822 }
54823
54824
54825 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54826   unsigned long jresult ;
54827   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54828   std::size_t result;
54829
54830   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54831   {
54832     try {
54833       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54834     } catch (std::out_of_range& e) {
54835       {
54836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54837       };
54838     } catch (std::exception& e) {
54839       {
54840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54841       };
54842     } catch (Dali::DaliException e) {
54843       {
54844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54845       };
54846     } catch (...) {
54847       {
54848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54849       };
54850     }
54851   }
54852
54853   jresult = (unsigned long)result;
54854   return jresult;
54855 }
54856
54857
54858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54859   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54860   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54861
54862   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54863   arg2 = (void (*)(Dali::Image))jarg2;
54864   {
54865     try {
54866       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54867     } catch (std::out_of_range& e) {
54868       {
54869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54870       };
54871     } catch (std::exception& e) {
54872       {
54873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54874       };
54875     } catch (Dali::DaliException e) {
54876       {
54877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54878       };
54879     } catch (...) {
54880       {
54881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54882       };
54883     }
54884   }
54885
54886 }
54887
54888
54889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54890   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54891   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54892
54893   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54894   arg2 = (void (*)(Dali::Image))jarg2;
54895   {
54896     try {
54897       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54898     } catch (std::out_of_range& e) {
54899       {
54900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54901       };
54902     } catch (std::exception& e) {
54903       {
54904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54905       };
54906     } catch (Dali::DaliException e) {
54907       {
54908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54909       };
54910     } catch (...) {
54911       {
54912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54913       };
54914     }
54915   }
54916
54917 }
54918
54919
54920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54921   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54922   Dali::Image arg2 ;
54923   Dali::Image *argp2 ;
54924
54925   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54926   argp2 = (Dali::Image *)jarg2;
54927   if (!argp2) {
54928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54929     return ;
54930   }
54931   arg2 = *argp2;
54932   {
54933     try {
54934       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54935     } catch (std::out_of_range& e) {
54936       {
54937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54938       };
54939     } catch (std::exception& e) {
54940       {
54941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54942       };
54943     } catch (Dali::DaliException e) {
54944       {
54945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54946       };
54947     } catch (...) {
54948       {
54949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54950       };
54951     }
54952   }
54953
54954 }
54955
54956
54957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54958   void * jresult ;
54959   Dali::Signal< void (Dali::Image) > *result = 0 ;
54960
54961   {
54962     try {
54963       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54964     } catch (std::out_of_range& e) {
54965       {
54966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54967       };
54968     } catch (std::exception& e) {
54969       {
54970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54971       };
54972     } catch (Dali::DaliException e) {
54973       {
54974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54975       };
54976     } catch (...) {
54977       {
54978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54979       };
54980     }
54981   }
54982
54983   jresult = (void *)result;
54984   return jresult;
54985 }
54986
54987
54988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54989   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54990
54991   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54992   {
54993     try {
54994       delete arg1;
54995     } catch (std::out_of_range& e) {
54996       {
54997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54998       };
54999     } catch (std::exception& e) {
55000       {
55001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55002       };
55003     } catch (Dali::DaliException e) {
55004       {
55005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55006       };
55007     } catch (...) {
55008       {
55009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55010       };
55011     }
55012   }
55013
55014 }
55015
55016
55017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55018   void * jresult ;
55019   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55020
55021   {
55022     try {
55023       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55024     } catch (std::out_of_range& e) {
55025       {
55026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55027       };
55028     } catch (std::exception& e) {
55029       {
55030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55031       };
55032     } catch (Dali::DaliException e) {
55033       {
55034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55035       };
55036     } catch (...) {
55037       {
55038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55039       };
55040     }
55041   }
55042
55043   jresult = (void *)result;
55044   return jresult;
55045 }
55046
55047
55048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55049   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55050
55051   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55052   {
55053     try {
55054       delete arg1;
55055     } catch (std::out_of_range& e) {
55056       {
55057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55058       };
55059     } catch (std::exception& e) {
55060       {
55061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55062       };
55063     } catch (Dali::DaliException e) {
55064       {
55065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55066       };
55067     } catch (...) {
55068       {
55069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55070       };
55071     }
55072   }
55073
55074 }
55075
55076
55077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55078   unsigned int jresult ;
55079   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55080   bool result;
55081
55082   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55083   {
55084     try {
55085       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);
55086     } catch (std::out_of_range& e) {
55087       {
55088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55089       };
55090     } catch (std::exception& e) {
55091       {
55092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55093       };
55094     } catch (Dali::DaliException e) {
55095       {
55096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55097       };
55098     } catch (...) {
55099       {
55100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55101       };
55102     }
55103   }
55104
55105   jresult = result;
55106   return jresult;
55107 }
55108
55109
55110 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55111   unsigned long jresult ;
55112   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55113   std::size_t result;
55114
55115   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55116   {
55117     try {
55118       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);
55119     } catch (std::out_of_range& e) {
55120       {
55121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55122       };
55123     } catch (std::exception& e) {
55124       {
55125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55126       };
55127     } catch (Dali::DaliException e) {
55128       {
55129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55130       };
55131     } catch (...) {
55132       {
55133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55134       };
55135     }
55136   }
55137
55138   jresult = (unsigned long)result;
55139   return jresult;
55140 }
55141
55142
55143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55144   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55145   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55146
55147   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55148   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55149   {
55150     try {
55151       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55152     } catch (std::out_of_range& e) {
55153       {
55154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55155       };
55156     } catch (std::exception& e) {
55157       {
55158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55159       };
55160     } catch (Dali::DaliException e) {
55161       {
55162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55163       };
55164     } catch (...) {
55165       {
55166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55167       };
55168     }
55169   }
55170
55171 }
55172
55173
55174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55175   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55176   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55177
55178   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55179   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55180   {
55181     try {
55182       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55183     } catch (std::out_of_range& e) {
55184       {
55185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55186       };
55187     } catch (std::exception& e) {
55188       {
55189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55190       };
55191     } catch (Dali::DaliException e) {
55192       {
55193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55194       };
55195     } catch (...) {
55196       {
55197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55198       };
55199     }
55200   }
55201
55202 }
55203
55204
55205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55206   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55207   Dali::Actor arg2 ;
55208   Dali::LongPressGesture *arg3 = 0 ;
55209   Dali::Actor *argp2 ;
55210
55211   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55212   argp2 = (Dali::Actor *)jarg2;
55213   if (!argp2) {
55214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55215     return ;
55216   }
55217   arg2 = *argp2;
55218   arg3 = (Dali::LongPressGesture *)jarg3;
55219   if (!arg3) {
55220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55221     return ;
55222   }
55223   {
55224     try {
55225       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55226     } catch (std::out_of_range& e) {
55227       {
55228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55229       };
55230     } catch (std::exception& e) {
55231       {
55232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55233       };
55234     } catch (Dali::DaliException e) {
55235       {
55236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55237       };
55238     } catch (...) {
55239       {
55240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55241       };
55242     }
55243   }
55244
55245 }
55246
55247
55248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55249   void * jresult ;
55250   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55251
55252   {
55253     try {
55254       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55255     } catch (std::out_of_range& e) {
55256       {
55257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55258       };
55259     } catch (std::exception& e) {
55260       {
55261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55262       };
55263     } catch (Dali::DaliException e) {
55264       {
55265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55266       };
55267     } catch (...) {
55268       {
55269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55270       };
55271     }
55272   }
55273
55274   jresult = (void *)result;
55275   return jresult;
55276 }
55277
55278
55279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55280   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55281
55282   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55283   {
55284     try {
55285       delete arg1;
55286     } catch (std::out_of_range& e) {
55287       {
55288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55289       };
55290     } catch (std::exception& e) {
55291       {
55292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55293       };
55294     } catch (Dali::DaliException e) {
55295       {
55296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55297       };
55298     } catch (...) {
55299       {
55300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55301       };
55302     }
55303   }
55304
55305 }
55306
55307
55308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55309   unsigned int jresult ;
55310   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55311   bool result;
55312
55313   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55314   {
55315     try {
55316       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);
55317     } catch (std::out_of_range& e) {
55318       {
55319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55320       };
55321     } catch (std::exception& e) {
55322       {
55323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55324       };
55325     } catch (Dali::DaliException e) {
55326       {
55327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55328       };
55329     } catch (...) {
55330       {
55331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55332       };
55333     }
55334   }
55335
55336   jresult = result;
55337   return jresult;
55338 }
55339
55340
55341 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55342   unsigned long jresult ;
55343   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55344   std::size_t result;
55345
55346   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55347   {
55348     try {
55349       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);
55350     } catch (std::out_of_range& e) {
55351       {
55352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55353       };
55354     } catch (std::exception& e) {
55355       {
55356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55357       };
55358     } catch (Dali::DaliException e) {
55359       {
55360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55361       };
55362     } catch (...) {
55363       {
55364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55365       };
55366     }
55367   }
55368
55369   jresult = (unsigned long)result;
55370   return jresult;
55371 }
55372
55373
55374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55375   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55376   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55377
55378   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55379   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55380   {
55381     try {
55382       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55383     } catch (std::out_of_range& e) {
55384       {
55385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55386       };
55387     } catch (std::exception& e) {
55388       {
55389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55390       };
55391     } catch (Dali::DaliException e) {
55392       {
55393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55394       };
55395     } catch (...) {
55396       {
55397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55398       };
55399     }
55400   }
55401
55402 }
55403
55404
55405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55406   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55407   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55408
55409   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55410   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55411   {
55412     try {
55413       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55414     } catch (std::out_of_range& e) {
55415       {
55416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55417       };
55418     } catch (std::exception& e) {
55419       {
55420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55421       };
55422     } catch (Dali::DaliException e) {
55423       {
55424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55425       };
55426     } catch (...) {
55427       {
55428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55429       };
55430     }
55431   }
55432
55433 }
55434
55435
55436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55437   unsigned int jresult ;
55438   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55439   Dali::Actor arg2 ;
55440   Dali::TouchData *arg3 = 0 ;
55441   Dali::Actor *argp2 ;
55442   bool result;
55443
55444   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55445   argp2 = (Dali::Actor *)jarg2;
55446   if (!argp2) {
55447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55448     return 0;
55449   }
55450   arg2 = *argp2;
55451   arg3 = (Dali::TouchData *)jarg3;
55452   if (!arg3) {
55453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55454     return 0;
55455   }
55456   {
55457     try {
55458       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55459     } catch (std::out_of_range& e) {
55460       {
55461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55462       };
55463     } catch (std::exception& e) {
55464       {
55465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55466       };
55467     } catch (Dali::DaliException e) {
55468       {
55469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55470       };
55471     } catch (...) {
55472       {
55473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55474       };
55475     }
55476   }
55477
55478   jresult = result;
55479   return jresult;
55480 }
55481
55482
55483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55484   void * jresult ;
55485   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55486
55487   {
55488     try {
55489       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55490     } catch (std::out_of_range& e) {
55491       {
55492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55493       };
55494     } catch (std::exception& e) {
55495       {
55496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55497       };
55498     } catch (Dali::DaliException e) {
55499       {
55500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55501       };
55502     } catch (...) {
55503       {
55504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55505       };
55506     }
55507   }
55508
55509   jresult = (void *)result;
55510   return jresult;
55511 }
55512
55513
55514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55515   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55516
55517   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55518   {
55519     try {
55520       delete arg1;
55521     } catch (std::out_of_range& e) {
55522       {
55523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55524       };
55525     } catch (std::exception& e) {
55526       {
55527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55528       };
55529     } catch (Dali::DaliException e) {
55530       {
55531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55532       };
55533     } catch (...) {
55534       {
55535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55536       };
55537     }
55538   }
55539
55540 }
55541
55542
55543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55544   unsigned int jresult ;
55545   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55546   bool result;
55547
55548   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55549   {
55550     try {
55551       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);
55552     } catch (std::out_of_range& e) {
55553       {
55554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55555       };
55556     } catch (std::exception& e) {
55557       {
55558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55559       };
55560     } catch (Dali::DaliException e) {
55561       {
55562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55563       };
55564     } catch (...) {
55565       {
55566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55567       };
55568     }
55569   }
55570
55571   jresult = result;
55572   return jresult;
55573 }
55574
55575
55576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55577   unsigned long jresult ;
55578   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55579   std::size_t result;
55580
55581   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55582   {
55583     try {
55584       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);
55585     } catch (std::out_of_range& e) {
55586       {
55587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55588       };
55589     } catch (std::exception& e) {
55590       {
55591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55592       };
55593     } catch (Dali::DaliException e) {
55594       {
55595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55596       };
55597     } catch (...) {
55598       {
55599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55600       };
55601     }
55602   }
55603
55604   jresult = (unsigned long)result;
55605   return jresult;
55606 }
55607
55608
55609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55610   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55611   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55612
55613   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55614   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55615   {
55616     try {
55617       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55618     } catch (std::out_of_range& e) {
55619       {
55620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55621       };
55622     } catch (std::exception& e) {
55623       {
55624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55625       };
55626     } catch (Dali::DaliException e) {
55627       {
55628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55629       };
55630     } catch (...) {
55631       {
55632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55633       };
55634     }
55635   }
55636
55637 }
55638
55639
55640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55641   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55642   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55643
55644   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55645   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55646   {
55647     try {
55648       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55649     } catch (std::out_of_range& e) {
55650       {
55651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55652       };
55653     } catch (std::exception& e) {
55654       {
55655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55656       };
55657     } catch (Dali::DaliException e) {
55658       {
55659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55660       };
55661     } catch (...) {
55662       {
55663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55664       };
55665     }
55666   }
55667
55668 }
55669
55670
55671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55672   unsigned int jresult ;
55673   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55674   Dali::Actor arg2 ;
55675   Dali::HoverEvent *arg3 = 0 ;
55676   Dali::Actor *argp2 ;
55677   bool result;
55678
55679   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55680   argp2 = (Dali::Actor *)jarg2;
55681   if (!argp2) {
55682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55683     return 0;
55684   }
55685   arg2 = *argp2;
55686   arg3 = (Dali::HoverEvent *)jarg3;
55687   if (!arg3) {
55688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55689     return 0;
55690   }
55691   {
55692     try {
55693       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55694     } catch (std::out_of_range& e) {
55695       {
55696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55697       };
55698     } catch (std::exception& e) {
55699       {
55700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55701       };
55702     } catch (Dali::DaliException e) {
55703       {
55704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55705       };
55706     } catch (...) {
55707       {
55708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55709       };
55710     }
55711   }
55712
55713   jresult = result;
55714   return jresult;
55715 }
55716
55717
55718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55719   void * jresult ;
55720   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55721
55722   {
55723     try {
55724       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55725     } catch (std::out_of_range& e) {
55726       {
55727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55728       };
55729     } catch (std::exception& e) {
55730       {
55731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55732       };
55733     } catch (Dali::DaliException e) {
55734       {
55735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55736       };
55737     } catch (...) {
55738       {
55739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55740       };
55741     }
55742   }
55743
55744   jresult = (void *)result;
55745   return jresult;
55746 }
55747
55748
55749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55750   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55751
55752   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55753   {
55754     try {
55755       delete arg1;
55756     } catch (std::out_of_range& e) {
55757       {
55758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55759       };
55760     } catch (std::exception& e) {
55761       {
55762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55763       };
55764     } catch (Dali::DaliException e) {
55765       {
55766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55767       };
55768     } catch (...) {
55769       {
55770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55771       };
55772     }
55773   }
55774
55775 }
55776
55777
55778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55779   unsigned int jresult ;
55780   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55781   bool result;
55782
55783   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55784   {
55785     try {
55786       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);
55787     } catch (std::out_of_range& e) {
55788       {
55789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55790       };
55791     } catch (std::exception& e) {
55792       {
55793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55794       };
55795     } catch (Dali::DaliException e) {
55796       {
55797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55798       };
55799     } catch (...) {
55800       {
55801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55802       };
55803     }
55804   }
55805
55806   jresult = result;
55807   return jresult;
55808 }
55809
55810
55811 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55812   unsigned long jresult ;
55813   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55814   std::size_t result;
55815
55816   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55817   {
55818     try {
55819       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);
55820     } catch (std::out_of_range& e) {
55821       {
55822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55823       };
55824     } catch (std::exception& e) {
55825       {
55826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55827       };
55828     } catch (Dali::DaliException e) {
55829       {
55830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55831       };
55832     } catch (...) {
55833       {
55834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55835       };
55836     }
55837   }
55838
55839   jresult = (unsigned long)result;
55840   return jresult;
55841 }
55842
55843
55844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55845   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55846   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55847
55848   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55849   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55850   {
55851     try {
55852       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55853     } catch (std::out_of_range& e) {
55854       {
55855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55856       };
55857     } catch (std::exception& e) {
55858       {
55859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55860       };
55861     } catch (Dali::DaliException e) {
55862       {
55863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55864       };
55865     } catch (...) {
55866       {
55867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55868       };
55869     }
55870   }
55871
55872 }
55873
55874
55875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55876   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55877   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55878
55879   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55880   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55881   {
55882     try {
55883       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55884     } catch (std::out_of_range& e) {
55885       {
55886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55887       };
55888     } catch (std::exception& e) {
55889       {
55890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55891       };
55892     } catch (Dali::DaliException e) {
55893       {
55894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55895       };
55896     } catch (...) {
55897       {
55898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55899       };
55900     }
55901   }
55902
55903 }
55904
55905
55906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55907   unsigned int jresult ;
55908   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55909   Dali::Actor arg2 ;
55910   Dali::WheelEvent *arg3 = 0 ;
55911   Dali::Actor *argp2 ;
55912   bool result;
55913
55914   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55915   argp2 = (Dali::Actor *)jarg2;
55916   if (!argp2) {
55917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55918     return 0;
55919   }
55920   arg2 = *argp2;
55921   arg3 = (Dali::WheelEvent *)jarg3;
55922   if (!arg3) {
55923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55924     return 0;
55925   }
55926   {
55927     try {
55928       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55929     } catch (std::out_of_range& e) {
55930       {
55931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55932       };
55933     } catch (std::exception& e) {
55934       {
55935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55936       };
55937     } catch (Dali::DaliException e) {
55938       {
55939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55940       };
55941     } catch (...) {
55942       {
55943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55944       };
55945     }
55946   }
55947
55948   jresult = result;
55949   return jresult;
55950 }
55951
55952
55953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55954   void * jresult ;
55955   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55956
55957   {
55958     try {
55959       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55960     } catch (std::out_of_range& e) {
55961       {
55962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55963       };
55964     } catch (std::exception& e) {
55965       {
55966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55967       };
55968     } catch (Dali::DaliException e) {
55969       {
55970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55971       };
55972     } catch (...) {
55973       {
55974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55975       };
55976     }
55977   }
55978
55979   jresult = (void *)result;
55980   return jresult;
55981 }
55982
55983
55984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55985   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55986
55987   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55988   {
55989     try {
55990       delete arg1;
55991     } catch (std::out_of_range& e) {
55992       {
55993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55994       };
55995     } catch (std::exception& e) {
55996       {
55997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55998       };
55999     } catch (Dali::DaliException e) {
56000       {
56001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56002       };
56003     } catch (...) {
56004       {
56005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56006       };
56007     }
56008   }
56009
56010 }
56011
56012
56013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56014   unsigned int jresult ;
56015   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56016   bool result;
56017
56018   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56019   {
56020     try {
56021       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56022     } catch (std::out_of_range& e) {
56023       {
56024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56025       };
56026     } catch (std::exception& e) {
56027       {
56028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56029       };
56030     } catch (Dali::DaliException e) {
56031       {
56032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56033       };
56034     } catch (...) {
56035       {
56036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56037       };
56038     }
56039   }
56040
56041   jresult = result;
56042   return jresult;
56043 }
56044
56045
56046 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56047   unsigned long jresult ;
56048   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56049   std::size_t result;
56050
56051   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56052   {
56053     try {
56054       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56055     } catch (std::out_of_range& e) {
56056       {
56057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56058       };
56059     } catch (std::exception& e) {
56060       {
56061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56062       };
56063     } catch (Dali::DaliException e) {
56064       {
56065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56066       };
56067     } catch (...) {
56068       {
56069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56070       };
56071     }
56072   }
56073
56074   jresult = (unsigned long)result;
56075   return jresult;
56076 }
56077
56078
56079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56080   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56081   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56082
56083   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56084   arg2 = (void (*)(Dali::Actor))jarg2;
56085   {
56086     try {
56087       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56088     } catch (std::out_of_range& e) {
56089       {
56090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56091       };
56092     } catch (std::exception& e) {
56093       {
56094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56095       };
56096     } catch (Dali::DaliException e) {
56097       {
56098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56099       };
56100     } catch (...) {
56101       {
56102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56103       };
56104     }
56105   }
56106
56107 }
56108
56109
56110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56111   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56112   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56113
56114   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56115   arg2 = (void (*)(Dali::Actor))jarg2;
56116   {
56117     try {
56118       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56119     } catch (std::out_of_range& e) {
56120       {
56121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56122       };
56123     } catch (std::exception& e) {
56124       {
56125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56126       };
56127     } catch (Dali::DaliException e) {
56128       {
56129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56130       };
56131     } catch (...) {
56132       {
56133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56134       };
56135     }
56136   }
56137
56138 }
56139
56140
56141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56142   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56143   Dali::Actor arg2 ;
56144   Dali::Actor *argp2 ;
56145
56146   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56147   argp2 = (Dali::Actor *)jarg2;
56148   if (!argp2) {
56149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56150     return ;
56151   }
56152   arg2 = *argp2;
56153   {
56154     try {
56155       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56156     } catch (std::out_of_range& e) {
56157       {
56158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56159       };
56160     } catch (std::exception& e) {
56161       {
56162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56163       };
56164     } catch (Dali::DaliException e) {
56165       {
56166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56167       };
56168     } catch (...) {
56169       {
56170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56171       };
56172     }
56173   }
56174
56175 }
56176
56177
56178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56179   void * jresult ;
56180   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56181
56182   {
56183     try {
56184       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (Dali::DaliException e) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56196       };
56197     } catch (...) {
56198       {
56199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56200       };
56201     }
56202   }
56203
56204   jresult = (void *)result;
56205   return jresult;
56206 }
56207
56208
56209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56210   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56211
56212   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56213   {
56214     try {
56215       delete arg1;
56216     } catch (std::out_of_range& e) {
56217       {
56218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56219       };
56220     } catch (std::exception& e) {
56221       {
56222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56223       };
56224     } catch (Dali::DaliException e) {
56225       {
56226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56227       };
56228     } catch (...) {
56229       {
56230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56231       };
56232     }
56233   }
56234
56235 }
56236
56237
56238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56239   unsigned int jresult ;
56240   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56241   bool result;
56242
56243   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56244   {
56245     try {
56246       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56247     } catch (std::out_of_range& e) {
56248       {
56249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56250       };
56251     } catch (std::exception& e) {
56252       {
56253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56254       };
56255     } catch (Dali::DaliException e) {
56256       {
56257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56258       };
56259     } catch (...) {
56260       {
56261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56262       };
56263     }
56264   }
56265
56266   jresult = result;
56267   return jresult;
56268 }
56269
56270
56271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56272   unsigned long jresult ;
56273   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56274   std::size_t result;
56275
56276   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56277   {
56278     try {
56279       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56280     } catch (std::out_of_range& e) {
56281       {
56282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56283       };
56284     } catch (std::exception& e) {
56285       {
56286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56287       };
56288     } catch (Dali::DaliException e) {
56289       {
56290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56291       };
56292     } catch (...) {
56293       {
56294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56295       };
56296     }
56297   }
56298
56299   jresult = (unsigned long)result;
56300   return jresult;
56301 }
56302
56303
56304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56305   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56306   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56307
56308   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56309   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56310   {
56311     try {
56312       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56313     } catch (std::out_of_range& e) {
56314       {
56315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56316       };
56317     } catch (std::exception& e) {
56318       {
56319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56320       };
56321     } catch (Dali::DaliException e) {
56322       {
56323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56324       };
56325     } catch (...) {
56326       {
56327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56328       };
56329     }
56330   }
56331
56332 }
56333
56334
56335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56336   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56337   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56338
56339   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56340   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56341   {
56342     try {
56343       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56344     } catch (std::out_of_range& e) {
56345       {
56346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56347       };
56348     } catch (std::exception& e) {
56349       {
56350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56351       };
56352     } catch (Dali::DaliException e) {
56353       {
56354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56355       };
56356     } catch (...) {
56357       {
56358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56359       };
56360     }
56361   }
56362
56363 }
56364
56365
56366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56367   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56368   Dali::KeyEvent *arg2 = 0 ;
56369
56370   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56371   arg2 = (Dali::KeyEvent *)jarg2;
56372   if (!arg2) {
56373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56374     return ;
56375   }
56376   {
56377     try {
56378       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56379     } catch (std::out_of_range& e) {
56380       {
56381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56382       };
56383     } catch (std::exception& e) {
56384       {
56385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56386       };
56387     } catch (Dali::DaliException e) {
56388       {
56389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56390       };
56391     } catch (...) {
56392       {
56393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56394       };
56395     }
56396   }
56397
56398 }
56399
56400
56401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56402   void * jresult ;
56403   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56404
56405   {
56406     try {
56407       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56408     } catch (std::out_of_range& e) {
56409       {
56410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56411       };
56412     } catch (std::exception& e) {
56413       {
56414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56415       };
56416     } catch (Dali::DaliException e) {
56417       {
56418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56419       };
56420     } catch (...) {
56421       {
56422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56423       };
56424     }
56425   }
56426
56427   jresult = (void *)result;
56428   return jresult;
56429 }
56430
56431
56432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56433   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56434
56435   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56436   {
56437     try {
56438       delete arg1;
56439     } catch (std::out_of_range& e) {
56440       {
56441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56442       };
56443     } catch (std::exception& e) {
56444       {
56445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56446       };
56447     } catch (Dali::DaliException e) {
56448       {
56449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56450       };
56451     } catch (...) {
56452       {
56453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56454       };
56455     }
56456   }
56457
56458 }
56459
56460
56461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56462   unsigned int jresult ;
56463   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56464   bool result;
56465
56466   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56467   {
56468     try {
56469       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56470     } catch (std::out_of_range& e) {
56471       {
56472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56473       };
56474     } catch (std::exception& e) {
56475       {
56476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56477       };
56478     } catch (Dali::DaliException e) {
56479       {
56480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56481       };
56482     } catch (...) {
56483       {
56484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56485       };
56486     }
56487   }
56488
56489   jresult = result;
56490   return jresult;
56491 }
56492
56493
56494 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56495   unsigned long jresult ;
56496   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56497   std::size_t result;
56498
56499   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56500   {
56501     try {
56502       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56503     } catch (std::out_of_range& e) {
56504       {
56505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56506       };
56507     } catch (std::exception& e) {
56508       {
56509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56510       };
56511     } catch (Dali::DaliException e) {
56512       {
56513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56514       };
56515     } catch (...) {
56516       {
56517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56518       };
56519     }
56520   }
56521
56522   jresult = (unsigned long)result;
56523   return jresult;
56524 }
56525
56526
56527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56528   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56529   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56530
56531   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56532   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56533   {
56534     try {
56535       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56536     } catch (std::out_of_range& e) {
56537       {
56538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56539       };
56540     } catch (std::exception& e) {
56541       {
56542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56543       };
56544     } catch (Dali::DaliException e) {
56545       {
56546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56547       };
56548     } catch (...) {
56549       {
56550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56551       };
56552     }
56553   }
56554
56555 }
56556
56557
56558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56559   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56560   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56561
56562   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56563   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56564   {
56565     try {
56566       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56567     } catch (std::out_of_range& e) {
56568       {
56569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56570       };
56571     } catch (std::exception& e) {
56572       {
56573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56574       };
56575     } catch (Dali::DaliException e) {
56576       {
56577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56578       };
56579     } catch (...) {
56580       {
56581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56582       };
56583     }
56584   }
56585
56586 }
56587
56588
56589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56590   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56591   Dali::TouchData *arg2 = 0 ;
56592
56593   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56594   arg2 = (Dali::TouchData *)jarg2;
56595   if (!arg2) {
56596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56597     return ;
56598   }
56599   {
56600     try {
56601       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56602     } catch (std::out_of_range& e) {
56603       {
56604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56605       };
56606     } catch (std::exception& e) {
56607       {
56608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56609       };
56610     } catch (Dali::DaliException e) {
56611       {
56612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56613       };
56614     } catch (...) {
56615       {
56616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56617       };
56618     }
56619   }
56620
56621 }
56622
56623
56624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56625   void * jresult ;
56626   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56627
56628   {
56629     try {
56630       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56631     } catch (std::out_of_range& e) {
56632       {
56633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56634       };
56635     } catch (std::exception& e) {
56636       {
56637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56638       };
56639     } catch (Dali::DaliException e) {
56640       {
56641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56642       };
56643     } catch (...) {
56644       {
56645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56646       };
56647     }
56648   }
56649
56650   jresult = (void *)result;
56651   return jresult;
56652 }
56653
56654
56655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56656   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56657
56658   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56659   {
56660     try {
56661       delete arg1;
56662     } catch (std::out_of_range& e) {
56663       {
56664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56665       };
56666     } catch (std::exception& e) {
56667       {
56668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56669       };
56670     } catch (Dali::DaliException e) {
56671       {
56672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56673       };
56674     } catch (...) {
56675       {
56676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56677       };
56678     }
56679   }
56680
56681 }
56682
56683
56684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56685   unsigned int jresult ;
56686   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56687   bool result;
56688
56689   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56690   {
56691     try {
56692       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56693     } catch (std::out_of_range& e) {
56694       {
56695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56696       };
56697     } catch (std::exception& e) {
56698       {
56699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56700       };
56701     } catch (Dali::DaliException e) {
56702       {
56703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56704       };
56705     } catch (...) {
56706       {
56707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56708       };
56709     }
56710   }
56711
56712   jresult = result;
56713   return jresult;
56714 }
56715
56716
56717 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56718   unsigned long jresult ;
56719   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56720   std::size_t result;
56721
56722   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56723   {
56724     try {
56725       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56726     } catch (std::out_of_range& e) {
56727       {
56728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56729       };
56730     } catch (std::exception& e) {
56731       {
56732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56733       };
56734     } catch (Dali::DaliException e) {
56735       {
56736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56737       };
56738     } catch (...) {
56739       {
56740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56741       };
56742     }
56743   }
56744
56745   jresult = (unsigned long)result;
56746   return jresult;
56747 }
56748
56749
56750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56751   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56752   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56753
56754   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56755   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56756   {
56757     try {
56758       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56759     } catch (std::out_of_range& e) {
56760       {
56761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56762       };
56763     } catch (std::exception& e) {
56764       {
56765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56766       };
56767     } catch (Dali::DaliException e) {
56768       {
56769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56770       };
56771     } catch (...) {
56772       {
56773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56774       };
56775     }
56776   }
56777
56778 }
56779
56780
56781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56782   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56783   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56784
56785   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56786   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56787   {
56788     try {
56789       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56790     } catch (std::out_of_range& e) {
56791       {
56792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56793       };
56794     } catch (std::exception& e) {
56795       {
56796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56797       };
56798     } catch (Dali::DaliException e) {
56799       {
56800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56801       };
56802     } catch (...) {
56803       {
56804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56805       };
56806     }
56807   }
56808
56809 }
56810
56811
56812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56813   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56814   Dali::WheelEvent *arg2 = 0 ;
56815
56816   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56817   arg2 = (Dali::WheelEvent *)jarg2;
56818   if (!arg2) {
56819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56820     return ;
56821   }
56822   {
56823     try {
56824       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56825     } catch (std::out_of_range& e) {
56826       {
56827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56828       };
56829     } catch (std::exception& e) {
56830       {
56831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56832       };
56833     } catch (Dali::DaliException e) {
56834       {
56835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56836       };
56837     } catch (...) {
56838       {
56839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56840       };
56841     }
56842   }
56843
56844 }
56845
56846
56847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56848   void * jresult ;
56849   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56850
56851   {
56852     try {
56853       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56854     } catch (std::out_of_range& e) {
56855       {
56856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56857       };
56858     } catch (std::exception& e) {
56859       {
56860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56861       };
56862     } catch (Dali::DaliException e) {
56863       {
56864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56865       };
56866     } catch (...) {
56867       {
56868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56869       };
56870     }
56871   }
56872
56873   jresult = (void *)result;
56874   return jresult;
56875 }
56876
56877
56878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56879   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56880
56881   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56882   {
56883     try {
56884       delete arg1;
56885     } catch (std::out_of_range& e) {
56886       {
56887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56888       };
56889     } catch (std::exception& e) {
56890       {
56891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56892       };
56893     } catch (Dali::DaliException e) {
56894       {
56895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56896       };
56897     } catch (...) {
56898       {
56899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56900       };
56901     }
56902   }
56903
56904 }
56905
56906
56907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56908   void * jresult ;
56909   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56910
56911   {
56912     try {
56913       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56914     } catch (std::out_of_range& e) {
56915       {
56916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56917       };
56918     } catch (std::exception& e) {
56919       {
56920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56921       };
56922     } catch (Dali::DaliException e) {
56923       {
56924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56925       };
56926     } catch (...) {
56927       {
56928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56929       };
56930     }
56931   }
56932
56933   jresult = (void *)result;
56934   return jresult;
56935 }
56936
56937
56938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56939   void * jresult ;
56940   Dali::Radian arg1 ;
56941   Dali::Radian arg2 ;
56942   Dali::Radian *argp1 ;
56943   Dali::Radian *argp2 ;
56944   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56945
56946   argp1 = (Dali::Radian *)jarg1;
56947   if (!argp1) {
56948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56949     return 0;
56950   }
56951   arg1 = *argp1;
56952   argp2 = (Dali::Radian *)jarg2;
56953   if (!argp2) {
56954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56955     return 0;
56956   }
56957   arg2 = *argp2;
56958   {
56959     try {
56960       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56961     } catch (std::out_of_range& e) {
56962       {
56963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56964       };
56965     } catch (std::exception& e) {
56966       {
56967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56968       };
56969     } catch (Dali::DaliException e) {
56970       {
56971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56972       };
56973     } catch (...) {
56974       {
56975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56976       };
56977     }
56978   }
56979
56980   jresult = (void *)result;
56981   return jresult;
56982 }
56983
56984
56985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56986   void * jresult ;
56987   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56988   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56989
56990   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56991   if (!arg1) {
56992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56993     return 0;
56994   }
56995   {
56996     try {
56997       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56998     } catch (std::out_of_range& e) {
56999       {
57000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57001       };
57002     } catch (std::exception& e) {
57003       {
57004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57005       };
57006     } catch (Dali::DaliException e) {
57007       {
57008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57009       };
57010     } catch (...) {
57011       {
57012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57013       };
57014     }
57015   }
57016
57017   jresult = (void *)result;
57018   return jresult;
57019 }
57020
57021
57022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57023   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57024   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57025
57026   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57027   arg2 = (Dali::Radian *)jarg2;
57028   if (arg1) (arg1)->first = *arg2;
57029 }
57030
57031
57032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57033   void * jresult ;
57034   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57035   Dali::Radian *result = 0 ;
57036
57037   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57038   result = (Dali::Radian *)& ((arg1)->first);
57039   jresult = (void *)result;
57040   return jresult;
57041 }
57042
57043
57044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57045   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57046   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57047
57048   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57049   arg2 = (Dali::Radian *)jarg2;
57050   if (arg1) (arg1)->second = *arg2;
57051 }
57052
57053
57054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57055   void * jresult ;
57056   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57057   Dali::Radian *result = 0 ;
57058
57059   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57060   result = (Dali::Radian *)& ((arg1)->second);
57061   jresult = (void *)result;
57062   return jresult;
57063 }
57064
57065
57066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57067   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57068
57069   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57070   {
57071     try {
57072       delete arg1;
57073     } catch (std::out_of_range& e) {
57074       {
57075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57076       };
57077     } catch (std::exception& e) {
57078       {
57079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57080       };
57081     } catch (Dali::DaliException e) {
57082       {
57083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57084       };
57085     } catch (...) {
57086       {
57087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57088       };
57089     }
57090   }
57091
57092 }
57093
57094
57095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57096   unsigned int jresult ;
57097   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57098   bool result;
57099
57100   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57101   {
57102     try {
57103       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);
57104     } catch (std::out_of_range& e) {
57105       {
57106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57107       };
57108     } catch (std::exception& e) {
57109       {
57110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57111       };
57112     } catch (Dali::DaliException e) {
57113       {
57114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57115       };
57116     } catch (...) {
57117       {
57118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57119       };
57120     }
57121   }
57122
57123   jresult = result;
57124   return jresult;
57125 }
57126
57127
57128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57129   unsigned long jresult ;
57130   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57131   std::size_t result;
57132
57133   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57134   {
57135     try {
57136       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);
57137     } catch (std::out_of_range& e) {
57138       {
57139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57140       };
57141     } catch (std::exception& e) {
57142       {
57143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57144       };
57145     } catch (Dali::DaliException e) {
57146       {
57147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57148       };
57149     } catch (...) {
57150       {
57151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57152       };
57153     }
57154   }
57155
57156   jresult = (unsigned long)result;
57157   return jresult;
57158 }
57159
57160
57161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57162   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57163   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57164
57165   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57166   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57167   {
57168     try {
57169       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57170     } catch (std::out_of_range& e) {
57171       {
57172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57173       };
57174     } catch (std::exception& e) {
57175       {
57176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57177       };
57178     } catch (Dali::DaliException e) {
57179       {
57180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57181       };
57182     } catch (...) {
57183       {
57184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57185       };
57186     }
57187   }
57188
57189 }
57190
57191
57192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57193   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57194   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57195
57196   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57197   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57198   {
57199     try {
57200       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57201     } catch (std::out_of_range& e) {
57202       {
57203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57204       };
57205     } catch (std::exception& e) {
57206       {
57207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57208       };
57209     } catch (Dali::DaliException e) {
57210       {
57211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57212       };
57213     } catch (...) {
57214       {
57215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57216       };
57217     }
57218   }
57219
57220 }
57221
57222
57223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57224   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57225   Dali::Actor arg2 ;
57226   Dali::PanGesture *arg3 = 0 ;
57227   Dali::Actor *argp2 ;
57228
57229   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57230   argp2 = (Dali::Actor *)jarg2;
57231   if (!argp2) {
57232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57233     return ;
57234   }
57235   arg2 = *argp2;
57236   arg3 = (Dali::PanGesture *)jarg3;
57237   if (!arg3) {
57238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57239     return ;
57240   }
57241   {
57242     try {
57243       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57244     } catch (std::out_of_range& e) {
57245       {
57246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57247       };
57248     } catch (std::exception& e) {
57249       {
57250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57251       };
57252     } catch (Dali::DaliException e) {
57253       {
57254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57255       };
57256     } catch (...) {
57257       {
57258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57259       };
57260     }
57261   }
57262
57263 }
57264
57265
57266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57267   void * jresult ;
57268   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57269
57270   {
57271     try {
57272       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57273     } catch (std::out_of_range& e) {
57274       {
57275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57276       };
57277     } catch (std::exception& e) {
57278       {
57279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57280       };
57281     } catch (Dali::DaliException e) {
57282       {
57283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57284       };
57285     } catch (...) {
57286       {
57287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57288       };
57289     }
57290   }
57291
57292   jresult = (void *)result;
57293   return jresult;
57294 }
57295
57296
57297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57298   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57299
57300   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57301   {
57302     try {
57303       delete arg1;
57304     } catch (std::out_of_range& e) {
57305       {
57306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57307       };
57308     } catch (std::exception& e) {
57309       {
57310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57311       };
57312     } catch (Dali::DaliException e) {
57313       {
57314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57315       };
57316     } catch (...) {
57317       {
57318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57319       };
57320     }
57321   }
57322
57323 }
57324
57325
57326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57327   unsigned int jresult ;
57328   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57329   bool result;
57330
57331   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57332   {
57333     try {
57334       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);
57335     } catch (std::out_of_range& e) {
57336       {
57337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57338       };
57339     } catch (std::exception& e) {
57340       {
57341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57342       };
57343     } catch (Dali::DaliException e) {
57344       {
57345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57346       };
57347     } catch (...) {
57348       {
57349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57350       };
57351     }
57352   }
57353
57354   jresult = result;
57355   return jresult;
57356 }
57357
57358
57359 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57360   unsigned long jresult ;
57361   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57362   std::size_t result;
57363
57364   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57365   {
57366     try {
57367       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);
57368     } catch (std::out_of_range& e) {
57369       {
57370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57371       };
57372     } catch (std::exception& e) {
57373       {
57374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57375       };
57376     } catch (Dali::DaliException e) {
57377       {
57378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57379       };
57380     } catch (...) {
57381       {
57382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57383       };
57384     }
57385   }
57386
57387   jresult = (unsigned long)result;
57388   return jresult;
57389 }
57390
57391
57392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57393   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57394   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57395
57396   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57397   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57398   {
57399     try {
57400       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57401     } catch (std::out_of_range& e) {
57402       {
57403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57404       };
57405     } catch (std::exception& e) {
57406       {
57407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57408       };
57409     } catch (Dali::DaliException e) {
57410       {
57411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57412       };
57413     } catch (...) {
57414       {
57415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57416       };
57417     }
57418   }
57419
57420 }
57421
57422
57423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57424   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57425   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57426
57427   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57428   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57429   {
57430     try {
57431       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57432     } catch (std::out_of_range& e) {
57433       {
57434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57435       };
57436     } catch (std::exception& e) {
57437       {
57438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57439       };
57440     } catch (Dali::DaliException e) {
57441       {
57442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57443       };
57444     } catch (...) {
57445       {
57446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57447       };
57448     }
57449   }
57450
57451 }
57452
57453
57454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57455   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57456   Dali::Actor arg2 ;
57457   Dali::PinchGesture *arg3 = 0 ;
57458   Dali::Actor *argp2 ;
57459
57460   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57461   argp2 = (Dali::Actor *)jarg2;
57462   if (!argp2) {
57463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57464     return ;
57465   }
57466   arg2 = *argp2;
57467   arg3 = (Dali::PinchGesture *)jarg3;
57468   if (!arg3) {
57469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57470     return ;
57471   }
57472   {
57473     try {
57474       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57475     } catch (std::out_of_range& e) {
57476       {
57477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57478       };
57479     } catch (std::exception& e) {
57480       {
57481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57482       };
57483     } catch (Dali::DaliException e) {
57484       {
57485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57486       };
57487     } catch (...) {
57488       {
57489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57490       };
57491     }
57492   }
57493
57494 }
57495
57496
57497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57498   void * jresult ;
57499   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57500
57501   {
57502     try {
57503       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57504     } catch (std::out_of_range& e) {
57505       {
57506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57507       };
57508     } catch (std::exception& e) {
57509       {
57510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57511       };
57512     } catch (Dali::DaliException e) {
57513       {
57514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57515       };
57516     } catch (...) {
57517       {
57518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57519       };
57520     }
57521   }
57522
57523   jresult = (void *)result;
57524   return jresult;
57525 }
57526
57527
57528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57529   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57530
57531   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57532   {
57533     try {
57534       delete arg1;
57535     } catch (std::out_of_range& e) {
57536       {
57537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57538       };
57539     } catch (std::exception& e) {
57540       {
57541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57542       };
57543     } catch (Dali::DaliException e) {
57544       {
57545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57546       };
57547     } catch (...) {
57548       {
57549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57550       };
57551     }
57552   }
57553
57554 }
57555
57556
57557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57558   unsigned int jresult ;
57559   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57560   bool result;
57561
57562   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57563   {
57564     try {
57565       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);
57566     } catch (std::out_of_range& e) {
57567       {
57568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57569       };
57570     } catch (std::exception& e) {
57571       {
57572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57573       };
57574     } catch (Dali::DaliException e) {
57575       {
57576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57577       };
57578     } catch (...) {
57579       {
57580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57581       };
57582     }
57583   }
57584
57585   jresult = result;
57586   return jresult;
57587 }
57588
57589
57590 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57591   unsigned long jresult ;
57592   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57593   std::size_t result;
57594
57595   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57596   {
57597     try {
57598       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);
57599     } catch (std::out_of_range& e) {
57600       {
57601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57602       };
57603     } catch (std::exception& e) {
57604       {
57605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57606       };
57607     } catch (Dali::DaliException e) {
57608       {
57609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57610       };
57611     } catch (...) {
57612       {
57613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57614       };
57615     }
57616   }
57617
57618   jresult = (unsigned long)result;
57619   return jresult;
57620 }
57621
57622
57623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57624   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57625   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57626
57627   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57628   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57629   {
57630     try {
57631       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57632     } catch (std::out_of_range& e) {
57633       {
57634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57635       };
57636     } catch (std::exception& e) {
57637       {
57638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57639       };
57640     } catch (Dali::DaliException e) {
57641       {
57642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57643       };
57644     } catch (...) {
57645       {
57646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57647       };
57648     }
57649   }
57650
57651 }
57652
57653
57654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57655   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57656   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57657
57658   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57659   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57660   {
57661     try {
57662       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57663     } catch (std::out_of_range& e) {
57664       {
57665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57666       };
57667     } catch (std::exception& e) {
57668       {
57669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57670       };
57671     } catch (Dali::DaliException e) {
57672       {
57673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57674       };
57675     } catch (...) {
57676       {
57677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57678       };
57679     }
57680   }
57681
57682 }
57683
57684
57685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57686   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57687   Dali::Actor arg2 ;
57688   Dali::TapGesture *arg3 = 0 ;
57689   Dali::Actor *argp2 ;
57690
57691   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57692   argp2 = (Dali::Actor *)jarg2;
57693   if (!argp2) {
57694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57695     return ;
57696   }
57697   arg2 = *argp2;
57698   arg3 = (Dali::TapGesture *)jarg3;
57699   if (!arg3) {
57700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57701     return ;
57702   }
57703   {
57704     try {
57705       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57706     } catch (std::out_of_range& e) {
57707       {
57708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57709       };
57710     } catch (std::exception& e) {
57711       {
57712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57713       };
57714     } catch (Dali::DaliException e) {
57715       {
57716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57717       };
57718     } catch (...) {
57719       {
57720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57721       };
57722     }
57723   }
57724
57725 }
57726
57727
57728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57729   void * jresult ;
57730   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57731
57732   {
57733     try {
57734       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57735     } catch (std::out_of_range& e) {
57736       {
57737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57738       };
57739     } catch (std::exception& e) {
57740       {
57741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57742       };
57743     } catch (Dali::DaliException e) {
57744       {
57745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57746       };
57747     } catch (...) {
57748       {
57749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57750       };
57751     }
57752   }
57753
57754   jresult = (void *)result;
57755   return jresult;
57756 }
57757
57758
57759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57760   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57761
57762   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57763   {
57764     try {
57765       delete arg1;
57766     } catch (std::out_of_range& e) {
57767       {
57768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57769       };
57770     } catch (std::exception& e) {
57771       {
57772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57773       };
57774     } catch (Dali::DaliException e) {
57775       {
57776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57777       };
57778     } catch (...) {
57779       {
57780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57781       };
57782     }
57783   }
57784
57785 }
57786
57787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57788   unsigned int jresult ;
57789   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57790   bool result;
57791
57792   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57793   {
57794     try {
57795       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57796     } catch (std::out_of_range& e) {
57797       {
57798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57799       };
57800     } catch (std::exception& e) {
57801       {
57802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57803       };
57804     } catch (Dali::DaliException e) {
57805       {
57806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57807       };
57808     } catch (...) {
57809       {
57810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57811       };
57812     }
57813   }
57814
57815   jresult = result;
57816   return jresult;
57817 }
57818
57819
57820 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57821   unsigned long jresult ;
57822   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57823   std::size_t result;
57824
57825   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57826   {
57827     try {
57828       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57829     } catch (std::out_of_range& e) {
57830       {
57831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57832       };
57833     } catch (std::exception& e) {
57834       {
57835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57836       };
57837     } catch (Dali::DaliException e) {
57838       {
57839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57840       };
57841     } catch (...) {
57842       {
57843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57844       };
57845     }
57846   }
57847
57848   jresult = (unsigned long)result;
57849   return jresult;
57850 }
57851
57852
57853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57854   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57855   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57856
57857   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57858   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57859   {
57860     try {
57861       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57862     } catch (std::out_of_range& e) {
57863       {
57864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57865       };
57866     } catch (std::exception& e) {
57867       {
57868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57869       };
57870     } catch (Dali::DaliException e) {
57871       {
57872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57873       };
57874     } catch (...) {
57875       {
57876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57877       };
57878     }
57879   }
57880
57881 }
57882
57883
57884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57885   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57886   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57887
57888   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57889   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57890   {
57891     try {
57892       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57893     } catch (std::out_of_range& e) {
57894       {
57895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57896       };
57897     } catch (std::exception& e) {
57898       {
57899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57900       };
57901     } catch (Dali::DaliException e) {
57902       {
57903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57904       };
57905     } catch (...) {
57906       {
57907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57908       };
57909     }
57910   }
57911
57912 }
57913
57914
57915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57916   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57917   Dali::ResourceImage arg2 ;
57918   Dali::ResourceImage *argp2 ;
57919
57920   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57921   argp2 = (Dali::ResourceImage *)jarg2;
57922   if (!argp2) {
57923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57924     return ;
57925   }
57926   arg2 = *argp2;
57927   {
57928     try {
57929       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57930     } catch (std::out_of_range& e) {
57931       {
57932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57933       };
57934     } catch (std::exception& e) {
57935       {
57936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57937       };
57938     } catch (Dali::DaliException e) {
57939       {
57940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57941       };
57942     } catch (...) {
57943       {
57944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57945       };
57946     }
57947   }
57948
57949 }
57950
57951
57952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57953   void * jresult ;
57954   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57955
57956   {
57957     try {
57958       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57959     } catch (std::out_of_range& e) {
57960       {
57961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57962       };
57963     } catch (std::exception& e) {
57964       {
57965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57966       };
57967     } catch (Dali::DaliException e) {
57968       {
57969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57970       };
57971     } catch (...) {
57972       {
57973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57974       };
57975     }
57976   }
57977
57978   jresult = (void *)result;
57979   return jresult;
57980 }
57981
57982
57983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57984   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57985
57986   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57987   {
57988     try {
57989       delete arg1;
57990     } catch (std::out_of_range& e) {
57991       {
57992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57993       };
57994     } catch (std::exception& e) {
57995       {
57996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57997       };
57998     } catch (Dali::DaliException e) {
57999       {
58000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58001       };
58002     } catch (...) {
58003       {
58004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58005       };
58006     }
58007   }
58008
58009 }
58010
58011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58012   unsigned int jresult ;
58013   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58014   bool result = false;
58015
58016   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58017   {
58018     try {
58019       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);
58020     } catch (std::out_of_range& e) {
58021       {
58022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58023       };
58024     } catch (std::exception& e) {
58025       {
58026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58027       };
58028     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58029   }
58030   jresult = result;
58031   return jresult;
58032 }
58033
58034 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58035   unsigned long jresult ;
58036   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58037   std::size_t result = 0;
58038
58039   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58040   {
58041     try {
58042       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);
58043     } catch (std::out_of_range& e) {
58044       {
58045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58046       };
58047     } catch (std::exception& e) {
58048       {
58049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58050       };
58051     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58052   }
58053   jresult = (unsigned long)result;
58054   return jresult;
58055 }
58056
58057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58058   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58059   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58060
58061   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58062   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58063   {
58064     try {
58065       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58073       };
58074     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58075   }
58076 }
58077
58078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58079   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58080   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58081
58082   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58083   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58084   {
58085     try {
58086       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58087     } catch (std::out_of_range& e) {
58088       {
58089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58090       };
58091     } catch (std::exception& e) {
58092       {
58093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58094       };
58095     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58096   }
58097 }
58098
58099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58100   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58101   Dali::Actor arg2 ;
58102   //bool arg3 ;
58103   Dali::LayoutDirection::Type arg4 ;
58104   Dali::Actor *argp2 ;
58105
58106   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58107   argp2 = (Dali::Actor *)jarg2;
58108   if (!argp2) {
58109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58110     return ;
58111   }
58112   arg2 = *argp2;
58113   //arg3 = jarg3 ? true : false;
58114   arg4 = (Dali::LayoutDirection::Type)jarg4;
58115   {
58116     try {
58117       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58118     } catch (std::out_of_range& e) {
58119       {
58120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58121       };
58122     } catch (std::exception& e) {
58123       {
58124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58125       };
58126     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58127   }
58128 }
58129
58130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58131   void * jresult ;
58132   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58133
58134   {
58135     try {
58136       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
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 (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58146   }
58147   jresult = (void *)result;
58148   return jresult;
58149 }
58150
58151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58152   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58153
58154   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58155   {
58156     try {
58157       delete arg1;
58158     } catch (std::out_of_range& e) {
58159       {
58160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58161       };
58162     } catch (std::exception& e) {
58163       {
58164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58165       };
58166     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58167   }
58168 }
58169
58170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58171   unsigned int jresult ;
58172   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58173   bool result;
58174
58175   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58176   {
58177     try {
58178       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);
58179     } catch (std::out_of_range& e) {
58180       {
58181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58182       };
58183     } catch (std::exception& e) {
58184       {
58185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58186       };
58187     } catch (Dali::DaliException e) {
58188       {
58189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58190       };
58191     } catch (...) {
58192       {
58193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58194       };
58195     }
58196   }
58197
58198   jresult = result;
58199   return jresult;
58200 }
58201
58202
58203 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58204   unsigned long jresult ;
58205   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58206   std::size_t result;
58207
58208   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58209   {
58210     try {
58211       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);
58212     } catch (std::out_of_range& e) {
58213       {
58214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58215       };
58216     } catch (std::exception& e) {
58217       {
58218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58219       };
58220     } catch (Dali::DaliException e) {
58221       {
58222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58223       };
58224     } catch (...) {
58225       {
58226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58227       };
58228     }
58229   }
58230
58231   jresult = (unsigned long)result;
58232   return jresult;
58233 }
58234
58235
58236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58237   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58238   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58239
58240   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58241   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58242   {
58243     try {
58244       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58245     } catch (std::out_of_range& e) {
58246       {
58247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58248       };
58249     } catch (std::exception& e) {
58250       {
58251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58252       };
58253     } catch (Dali::DaliException e) {
58254       {
58255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58256       };
58257     } catch (...) {
58258       {
58259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58260       };
58261     }
58262   }
58263
58264 }
58265
58266
58267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58268   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58269   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58270
58271   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58272   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58273   {
58274     try {
58275       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58276     } catch (std::out_of_range& e) {
58277       {
58278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58279       };
58280     } catch (std::exception& e) {
58281       {
58282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58283       };
58284     } catch (Dali::DaliException e) {
58285       {
58286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58287       };
58288     } catch (...) {
58289       {
58290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58291       };
58292     }
58293   }
58294
58295 }
58296
58297
58298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58299   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58300   Dali::Actor arg2 ;
58301   bool arg3 ;
58302   Dali::DevelActor::VisibilityChange::Type arg4 ;
58303   Dali::Actor *argp2 ;
58304
58305   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58306   argp2 = (Dali::Actor *)jarg2;
58307   if (!argp2) {
58308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58309     return ;
58310   }
58311   arg2 = *argp2;
58312   arg3 = jarg3 ? true : false;
58313   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58314   {
58315     try {
58316       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58317     } catch (std::out_of_range& e) {
58318       {
58319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58320       };
58321     } catch (std::exception& e) {
58322       {
58323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58324       };
58325     } catch (Dali::DaliException e) {
58326       {
58327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58328       };
58329     } catch (...) {
58330       {
58331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58332       };
58333     }
58334   }
58335
58336 }
58337
58338
58339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58340   void * jresult ;
58341   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58342
58343   {
58344     try {
58345       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58346     } catch (std::out_of_range& e) {
58347       {
58348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58349       };
58350     } catch (std::exception& e) {
58351       {
58352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58353       };
58354     } catch (Dali::DaliException e) {
58355       {
58356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58357       };
58358     } catch (...) {
58359       {
58360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58361       };
58362     }
58363   }
58364
58365   jresult = (void *)result;
58366   return jresult;
58367 }
58368
58369
58370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58371   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58372
58373   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58374   {
58375     try {
58376       delete arg1;
58377     } catch (std::out_of_range& e) {
58378       {
58379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58380       };
58381     } catch (std::exception& e) {
58382       {
58383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58384       };
58385     } catch (Dali::DaliException e) {
58386       {
58387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58388       };
58389     } catch (...) {
58390       {
58391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58392       };
58393     }
58394   }
58395
58396 }
58397
58398
58399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58400   void * jresult ;
58401   Dali::Timer *result = 0 ;
58402
58403   {
58404     try {
58405       result = (Dali::Timer *)new Dali::Timer();
58406     } catch (std::out_of_range& e) {
58407       {
58408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58409       };
58410     } catch (std::exception& e) {
58411       {
58412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58413       };
58414     } catch (Dali::DaliException e) {
58415       {
58416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58417       };
58418     } catch (...) {
58419       {
58420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58421       };
58422     }
58423   }
58424
58425   jresult = (void *)result;
58426   return jresult;
58427 }
58428
58429
58430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58431   void * jresult ;
58432   unsigned int arg1 ;
58433   Dali::Timer result;
58434
58435   arg1 = (unsigned int)jarg1;
58436   {
58437     try {
58438       result = Dali::Timer::New(arg1);
58439     } catch (std::out_of_range& e) {
58440       {
58441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58442       };
58443     } catch (std::exception& e) {
58444       {
58445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58446       };
58447     } catch (Dali::DaliException e) {
58448       {
58449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58450       };
58451     } catch (...) {
58452       {
58453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58454       };
58455     }
58456   }
58457
58458   jresult = new Dali::Timer((const Dali::Timer &)result);
58459   return jresult;
58460 }
58461
58462
58463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58464   void * jresult ;
58465   Dali::Timer *arg1 = 0 ;
58466   Dali::Timer *result = 0 ;
58467
58468   arg1 = (Dali::Timer *)jarg1;
58469   if (!arg1) {
58470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58471     return 0;
58472   }
58473   {
58474     try {
58475       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58476     } catch (std::out_of_range& e) {
58477       {
58478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58479       };
58480     } catch (std::exception& e) {
58481       {
58482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58483       };
58484     } catch (Dali::DaliException e) {
58485       {
58486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58487       };
58488     } catch (...) {
58489       {
58490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58491       };
58492     }
58493   }
58494
58495   jresult = (void *)result;
58496   return jresult;
58497 }
58498
58499
58500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58501   void * jresult ;
58502   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58503   Dali::Timer *arg2 = 0 ;
58504   Dali::Timer *result = 0 ;
58505
58506   arg1 = (Dali::Timer *)jarg1;
58507   arg2 = (Dali::Timer *)jarg2;
58508   if (!arg2) {
58509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58510     return 0;
58511   }
58512   {
58513     try {
58514       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58515     } catch (std::out_of_range& e) {
58516       {
58517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58518       };
58519     } catch (std::exception& e) {
58520       {
58521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58522       };
58523     } catch (Dali::DaliException e) {
58524       {
58525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58526       };
58527     } catch (...) {
58528       {
58529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58530       };
58531     }
58532   }
58533
58534   jresult = (void *)result;
58535   return jresult;
58536 }
58537
58538
58539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58540   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58541
58542   arg1 = (Dali::Timer *)jarg1;
58543   {
58544     try {
58545       delete arg1;
58546     } catch (std::out_of_range& e) {
58547       {
58548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58549       };
58550     } catch (std::exception& e) {
58551       {
58552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58553       };
58554     } catch (Dali::DaliException e) {
58555       {
58556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58557       };
58558     } catch (...) {
58559       {
58560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58561       };
58562     }
58563   }
58564
58565 }
58566
58567
58568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58569   void * jresult ;
58570   Dali::BaseHandle arg1 ;
58571   Dali::BaseHandle *argp1 ;
58572   Dali::Timer result;
58573
58574   argp1 = (Dali::BaseHandle *)jarg1;
58575   if (!argp1) {
58576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58577     return 0;
58578   }
58579   arg1 = *argp1;
58580   {
58581     try {
58582       result = Dali::Timer::DownCast(arg1);
58583     } catch (std::out_of_range& e) {
58584       {
58585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58586       };
58587     } catch (std::exception& e) {
58588       {
58589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58590       };
58591     } catch (Dali::DaliException e) {
58592       {
58593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58594       };
58595     } catch (...) {
58596       {
58597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58598       };
58599     }
58600   }
58601
58602   jresult = new Dali::Timer((const Dali::Timer &)result);
58603   return jresult;
58604 }
58605
58606
58607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58608   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58609
58610   arg1 = (Dali::Timer *)jarg1;
58611   {
58612     try {
58613       (arg1)->Start();
58614     } catch (std::out_of_range& e) {
58615       {
58616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58617       };
58618     } catch (std::exception& e) {
58619       {
58620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58621       };
58622     } catch (Dali::DaliException e) {
58623       {
58624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58625       };
58626     } catch (...) {
58627       {
58628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58629       };
58630     }
58631   }
58632
58633 }
58634
58635
58636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58637   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58638
58639   arg1 = (Dali::Timer *)jarg1;
58640   {
58641     try {
58642       (arg1)->Stop();
58643     } catch (std::out_of_range& e) {
58644       {
58645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58646       };
58647     } catch (std::exception& e) {
58648       {
58649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58650       };
58651     } catch (Dali::DaliException e) {
58652       {
58653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58654       };
58655     } catch (...) {
58656       {
58657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58658       };
58659     }
58660   }
58661
58662 }
58663
58664
58665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58666   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58667   unsigned int arg2 ;
58668
58669   arg1 = (Dali::Timer *)jarg1;
58670   arg2 = (unsigned int)jarg2;
58671   {
58672     try {
58673       (arg1)->SetInterval(arg2);
58674     } catch (std::out_of_range& e) {
58675       {
58676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58677       };
58678     } catch (std::exception& e) {
58679       {
58680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58681       };
58682     } catch (Dali::DaliException e) {
58683       {
58684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58685       };
58686     } catch (...) {
58687       {
58688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58689       };
58690     }
58691   }
58692
58693 }
58694
58695
58696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58697   unsigned int jresult ;
58698   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58699   unsigned int result;
58700
58701   arg1 = (Dali::Timer *)jarg1;
58702   {
58703     try {
58704       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58705     } catch (std::out_of_range& e) {
58706       {
58707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58708       };
58709     } catch (std::exception& e) {
58710       {
58711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58712       };
58713     } catch (Dali::DaliException e) {
58714       {
58715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58716       };
58717     } catch (...) {
58718       {
58719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58720       };
58721     }
58722   }
58723
58724   jresult = result;
58725   return jresult;
58726 }
58727
58728
58729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58730   unsigned int jresult ;
58731   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58732   bool result;
58733
58734   arg1 = (Dali::Timer *)jarg1;
58735   {
58736     try {
58737       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58738     } catch (std::out_of_range& e) {
58739       {
58740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58741       };
58742     } catch (std::exception& e) {
58743       {
58744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58745       };
58746     } catch (Dali::DaliException e) {
58747       {
58748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58749       };
58750     } catch (...) {
58751       {
58752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58753       };
58754     }
58755   }
58756
58757   jresult = result;
58758   return jresult;
58759 }
58760
58761
58762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58763   void * jresult ;
58764   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58765   Dali::Timer::TimerSignalType *result = 0 ;
58766
58767   arg1 = (Dali::Timer *)jarg1;
58768   {
58769     try {
58770       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58771     } catch (std::out_of_range& e) {
58772       {
58773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58774       };
58775     } catch (std::exception& e) {
58776       {
58777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58778       };
58779     } catch (Dali::DaliException e) {
58780       {
58781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58782       };
58783     } catch (...) {
58784       {
58785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58786       };
58787     }
58788   }
58789
58790   jresult = (void *)result;
58791   return jresult;
58792 }
58793
58794
58795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58796   void * jresult ;
58797   Dali::DragAndDropDetector *result = 0 ;
58798
58799   {
58800     try {
58801       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58802     } catch (std::out_of_range& e) {
58803       {
58804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58805       };
58806     } catch (std::exception& e) {
58807       {
58808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58809       };
58810     } catch (Dali::DaliException e) {
58811       {
58812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58813       };
58814     } catch (...) {
58815       {
58816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58817       };
58818     }
58819   }
58820
58821   jresult = (void *)result;
58822   return jresult;
58823 }
58824
58825
58826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58827   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58828
58829   arg1 = (Dali::DragAndDropDetector *)jarg1;
58830   {
58831     try {
58832       delete arg1;
58833     } catch (std::out_of_range& e) {
58834       {
58835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58836       };
58837     } catch (std::exception& e) {
58838       {
58839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58840       };
58841     } catch (Dali::DaliException e) {
58842       {
58843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58844       };
58845     } catch (...) {
58846       {
58847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58848       };
58849     }
58850   }
58851
58852 }
58853
58854
58855 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58856   char * jresult ;
58857   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58858   std::string *result = 0 ;
58859
58860   arg1 = (Dali::DragAndDropDetector *)jarg1;
58861   {
58862     try {
58863       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58864     } catch (std::out_of_range& e) {
58865       {
58866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58867       };
58868     } catch (std::exception& e) {
58869       {
58870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58871       };
58872     } catch (Dali::DaliException e) {
58873       {
58874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58875       };
58876     } catch (...) {
58877       {
58878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58879       };
58880     }
58881   }
58882
58883   jresult = SWIG_csharp_string_callback(result->c_str());
58884   return jresult;
58885 }
58886
58887
58888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58889   void * jresult ;
58890   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58891   Dali::Vector2 result;
58892
58893   arg1 = (Dali::DragAndDropDetector *)jarg1;
58894   {
58895     try {
58896       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58897     } catch (std::out_of_range& e) {
58898       {
58899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58900       };
58901     } catch (std::exception& e) {
58902       {
58903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58904       };
58905     } catch (Dali::DaliException e) {
58906       {
58907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58908       };
58909     } catch (...) {
58910       {
58911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58912       };
58913     }
58914   }
58915
58916   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58917   return jresult;
58918 }
58919
58920
58921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58922   void * jresult ;
58923   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58924   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58925
58926   arg1 = (Dali::DragAndDropDetector *)jarg1;
58927   {
58928     try {
58929       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58930     } catch (std::out_of_range& e) {
58931       {
58932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58933       };
58934     } catch (std::exception& e) {
58935       {
58936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58937       };
58938     } catch (Dali::DaliException e) {
58939       {
58940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58941       };
58942     } catch (...) {
58943       {
58944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58945       };
58946     }
58947   }
58948
58949   jresult = (void *)result;
58950   return jresult;
58951 }
58952
58953
58954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58955   void * jresult ;
58956   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58957   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58958
58959   arg1 = (Dali::DragAndDropDetector *)jarg1;
58960   {
58961     try {
58962       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58963     } catch (std::out_of_range& e) {
58964       {
58965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58966       };
58967     } catch (std::exception& e) {
58968       {
58969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58970       };
58971     } catch (Dali::DaliException e) {
58972       {
58973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58974       };
58975     } catch (...) {
58976       {
58977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58978       };
58979     }
58980   }
58981
58982   jresult = (void *)result;
58983   return jresult;
58984 }
58985
58986
58987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58988   void * jresult ;
58989   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58990   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58991
58992   arg1 = (Dali::DragAndDropDetector *)jarg1;
58993   {
58994     try {
58995       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58996     } catch (std::out_of_range& e) {
58997       {
58998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58999       };
59000     } catch (std::exception& e) {
59001       {
59002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59003       };
59004     } catch (Dali::DaliException e) {
59005       {
59006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59007       };
59008     } catch (...) {
59009       {
59010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59011       };
59012     }
59013   }
59014
59015   jresult = (void *)result;
59016   return jresult;
59017 }
59018
59019
59020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
59021   void * jresult ;
59022   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
59023   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
59024
59025   arg1 = (Dali::DragAndDropDetector *)jarg1;
59026   {
59027     try {
59028       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
59029     } catch (std::out_of_range& e) {
59030       {
59031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59032       };
59033     } catch (std::exception& e) {
59034       {
59035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59036       };
59037     } catch (Dali::DaliException e) {
59038       {
59039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59040       };
59041     } catch (...) {
59042       {
59043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59044       };
59045     }
59046   }
59047
59048   jresult = (void *)result;
59049   return jresult;
59050 }
59051
59052
59053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59054   void * jresult ;
59055   Dali::ApplicationExtensions *result = 0 ;
59056
59057   {
59058     try {
59059       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59060     } catch (std::out_of_range& e) {
59061       {
59062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59063       };
59064     } catch (std::exception& e) {
59065       {
59066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59067       };
59068     } catch (Dali::DaliException e) {
59069       {
59070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59071       };
59072     } catch (...) {
59073       {
59074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59075       };
59076     }
59077   }
59078
59079   jresult = (void *)result;
59080   return jresult;
59081 }
59082
59083
59084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59085   void * jresult ;
59086   Dali::Application *arg1 = (Dali::Application *) 0 ;
59087   Dali::ApplicationExtensions *result = 0 ;
59088
59089   arg1 = (Dali::Application *)jarg1;
59090   {
59091     try {
59092       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59093     } catch (std::out_of_range& e) {
59094       {
59095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59096       };
59097     } catch (std::exception& e) {
59098       {
59099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59100       };
59101     } catch (Dali::DaliException e) {
59102       {
59103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59104       };
59105     } catch (...) {
59106       {
59107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59108       };
59109     }
59110   }
59111
59112   jresult = (void *)result;
59113   return jresult;
59114 }
59115
59116
59117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59118   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59119
59120   arg1 = (Dali::ApplicationExtensions *)jarg1;
59121   {
59122     try {
59123       delete arg1;
59124     } catch (std::out_of_range& e) {
59125       {
59126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59127       };
59128     } catch (std::exception& e) {
59129       {
59130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59131       };
59132     } catch (Dali::DaliException e) {
59133       {
59134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59135       };
59136     } catch (...) {
59137       {
59138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59139       };
59140     }
59141   }
59142
59143 }
59144
59145
59146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59147   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59148
59149   arg1 = (Dali::ApplicationExtensions *)jarg1;
59150   {
59151     try {
59152       (arg1)->Init();
59153     } catch (std::out_of_range& e) {
59154       {
59155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59156       };
59157     } catch (std::exception& e) {
59158       {
59159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59160       };
59161     } catch (Dali::DaliException e) {
59162       {
59163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59164       };
59165     } catch (...) {
59166       {
59167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59168       };
59169     }
59170   }
59171
59172 }
59173
59174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59175   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59176
59177   arg1 = (Dali::ApplicationExtensions *)jarg1;
59178   {
59179     try {
59180       (arg1)->Start();
59181     } catch (std::out_of_range& e) {
59182       {
59183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59184       };
59185     } catch (std::exception& e) {
59186       {
59187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59188       };
59189     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59190   }
59191 }
59192
59193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59194   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59195
59196   arg1 = (Dali::ApplicationExtensions *)jarg1;
59197   {
59198     try {
59199       (arg1)->Terminate();
59200     } catch (std::out_of_range& e) {
59201       {
59202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59203       };
59204     } catch (std::exception& e) {
59205       {
59206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59207       };
59208     } catch (Dali::DaliException e) {
59209       {
59210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59211       };
59212     } catch (...) {
59213       {
59214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59215       };
59216     }
59217   }
59218
59219 }
59220
59221
59222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59223   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59224
59225   arg1 = (Dali::ApplicationExtensions *)jarg1;
59226   {
59227     try {
59228       (arg1)->Pause();
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59236       };
59237     } catch (Dali::DaliException e) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59240       };
59241     } catch (...) {
59242       {
59243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59244       };
59245     }
59246   }
59247
59248 }
59249
59250
59251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59252   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59253
59254   arg1 = (Dali::ApplicationExtensions *)jarg1;
59255   {
59256     try {
59257       (arg1)->Resume();
59258     } catch (std::out_of_range& e) {
59259       {
59260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59261       };
59262     } catch (std::exception& e) {
59263       {
59264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59265       };
59266     } catch (Dali::DaliException e) {
59267       {
59268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59269       };
59270     } catch (...) {
59271       {
59272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59273       };
59274     }
59275   }
59276
59277 }
59278
59279
59280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59281   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59282
59283   arg1 = (Dali::ApplicationExtensions *)jarg1;
59284   {
59285     try {
59286       (arg1)->LanguageChange();
59287     } catch (std::out_of_range& e) {
59288       {
59289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59290       };
59291     } catch (std::exception& e) {
59292       {
59293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59294       };
59295     } catch (Dali::DaliException e) {
59296       {
59297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59298       };
59299     } catch (...) {
59300       {
59301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59302       };
59303     }
59304   }
59305
59306 }
59307
59308
59309
59310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59311   unsigned int jresult ;
59312   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59313   bool result;
59314
59315   arg1 = (Dali::Signal< bool () > *)jarg1;
59316   {
59317     try {
59318       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59319     } catch (std::out_of_range& e) {
59320       {
59321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59322       };
59323     } catch (std::exception& e) {
59324       {
59325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59326       };
59327     } catch (Dali::DaliException e) {
59328       {
59329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59330       };
59331     } catch (...) {
59332       {
59333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59334       };
59335     }
59336   }
59337
59338   jresult = result;
59339   return jresult;
59340 }
59341
59342
59343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59344   unsigned long jresult ;
59345   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59346   std::size_t result;
59347
59348   arg1 = (Dali::Signal< bool () > *)jarg1;
59349   {
59350     try {
59351       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59352     } catch (std::out_of_range& e) {
59353       {
59354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59355       };
59356     } catch (std::exception& e) {
59357       {
59358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59359       };
59360     } catch (Dali::DaliException e) {
59361       {
59362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59363       };
59364     } catch (...) {
59365       {
59366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59367       };
59368     }
59369   }
59370
59371   jresult = (unsigned long)result;
59372   return jresult;
59373 }
59374
59375
59376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59377   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59378   bool (*arg2)() = (bool (*)()) 0 ;
59379
59380   arg1 = (Dali::Signal< bool () > *)jarg1;
59381   arg2 = (bool (*)())jarg2;
59382   {
59383     try {
59384       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59385     } catch (std::out_of_range& e) {
59386       {
59387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59388       };
59389     } catch (std::exception& e) {
59390       {
59391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59392       };
59393     } catch (Dali::DaliException e) {
59394       {
59395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59396       };
59397     } catch (...) {
59398       {
59399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59400       };
59401     }
59402   }
59403
59404 }
59405
59406
59407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59408   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59409   bool (*arg2)() = (bool (*)()) 0 ;
59410
59411   arg1 = (Dali::Signal< bool () > *)jarg1;
59412   arg2 = (bool (*)())jarg2;
59413   {
59414     try {
59415       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59416     } catch (std::out_of_range& e) {
59417       {
59418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59419       };
59420     } catch (std::exception& e) {
59421       {
59422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59423       };
59424     } catch (Dali::DaliException e) {
59425       {
59426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59427       };
59428     } catch (...) {
59429       {
59430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59431       };
59432     }
59433   }
59434
59435 }
59436
59437
59438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59439   unsigned int jresult ;
59440   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59441   bool result;
59442
59443   arg1 = (Dali::Signal< bool () > *)jarg1;
59444   {
59445     try {
59446       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59447     } catch (std::out_of_range& e) {
59448       {
59449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59450       };
59451     } catch (std::exception& e) {
59452       {
59453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59454       };
59455     } catch (Dali::DaliException e) {
59456       {
59457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59458       };
59459     } catch (...) {
59460       {
59461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59462       };
59463     }
59464   }
59465
59466   jresult = result;
59467   return jresult;
59468 }
59469
59470
59471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59472   void * jresult ;
59473   Dali::Signal< bool () > *result = 0 ;
59474
59475   {
59476     try {
59477       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59478     } catch (std::out_of_range& e) {
59479       {
59480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59481       };
59482     } catch (std::exception& e) {
59483       {
59484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59485       };
59486     } catch (Dali::DaliException e) {
59487       {
59488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59489       };
59490     } catch (...) {
59491       {
59492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59493       };
59494     }
59495   }
59496
59497   jresult = (void *)result;
59498   return jresult;
59499 }
59500
59501
59502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59503   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59504
59505   arg1 = (Dali::Signal< bool () > *)jarg1;
59506   {
59507     try {
59508       delete arg1;
59509     } catch (std::out_of_range& e) {
59510       {
59511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59512       };
59513     } catch (std::exception& e) {
59514       {
59515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59516       };
59517     } catch (Dali::DaliException e) {
59518       {
59519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59520       };
59521     } catch (...) {
59522       {
59523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59524       };
59525     }
59526   }
59527
59528 }
59529
59530
59531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59532   int jresult ;
59533   int result;
59534
59535   {
59536     try {
59537       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59538     } catch (std::out_of_range& e) {
59539       {
59540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (std::exception& e) {
59543       {
59544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59545       };
59546     } catch (Dali::DaliException e) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59549       };
59550     } catch (...) {
59551       {
59552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59553       };
59554     }
59555   }
59556
59557   jresult = (int)result;
59558   return jresult;
59559 }
59560
59561
59562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59563   int jresult ;
59564   int result;
59565
59566   {
59567     try {
59568       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59569     } catch (std::out_of_range& e) {
59570       {
59571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59572       };
59573     } catch (std::exception& e) {
59574       {
59575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59576       };
59577     } catch (Dali::DaliException e) {
59578       {
59579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59580       };
59581     } catch (...) {
59582       {
59583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59584       };
59585     }
59586   }
59587
59588   jresult = (int)result;
59589   return jresult;
59590 }
59591
59592
59593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59594   int jresult ;
59595   int result;
59596
59597   {
59598     try {
59599       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59600     } catch (std::out_of_range& e) {
59601       {
59602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59603       };
59604     } catch (std::exception& e) {
59605       {
59606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59607       };
59608     } catch (Dali::DaliException e) {
59609       {
59610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59611       };
59612     } catch (...) {
59613       {
59614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59615       };
59616     }
59617   }
59618
59619   jresult = (int)result;
59620   return jresult;
59621 }
59622
59623
59624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59625   int jresult ;
59626   int result;
59627
59628   {
59629     try {
59630       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59631     } catch (std::out_of_range& e) {
59632       {
59633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59634       };
59635     } catch (std::exception& e) {
59636       {
59637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59638       };
59639     } catch (Dali::DaliException e) {
59640       {
59641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59642       };
59643     } catch (...) {
59644       {
59645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59646       };
59647     }
59648   }
59649
59650   jresult = (int)result;
59651   return jresult;
59652 }
59653
59654
59655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59656   int jresult ;
59657   int result;
59658
59659   {
59660     try {
59661       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59662     } catch (std::out_of_range& e) {
59663       {
59664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (std::exception& e) {
59667       {
59668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59669       };
59670     } catch (Dali::DaliException e) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59673       };
59674     } catch (...) {
59675       {
59676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59677       };
59678     }
59679   }
59680
59681   jresult = (int)result;
59682   return jresult;
59683 }
59684
59685
59686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59687   int jresult ;
59688   int result;
59689
59690   {
59691     try {
59692       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59693     } catch (std::out_of_range& e) {
59694       {
59695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59696       };
59697     } catch (std::exception& e) {
59698       {
59699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59700       };
59701     } catch (Dali::DaliException e) {
59702       {
59703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59704       };
59705     } catch (...) {
59706       {
59707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59708       };
59709     }
59710   }
59711
59712   jresult = (int)result;
59713   return jresult;
59714 }
59715
59716
59717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59718   int jresult ;
59719   int result;
59720
59721   {
59722     try {
59723       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59724     } catch (std::out_of_range& e) {
59725       {
59726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59727       };
59728     } catch (std::exception& e) {
59729       {
59730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59731       };
59732     } catch (Dali::DaliException e) {
59733       {
59734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59735       };
59736     } catch (...) {
59737       {
59738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59739       };
59740     }
59741   }
59742
59743   jresult = (int)result;
59744   return jresult;
59745 }
59746
59747
59748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59749   int jresult ;
59750   int result;
59751
59752   {
59753     try {
59754       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59755     } catch (std::out_of_range& e) {
59756       {
59757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59758       };
59759     } catch (std::exception& e) {
59760       {
59761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59762       };
59763     } catch (Dali::DaliException e) {
59764       {
59765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59766       };
59767     } catch (...) {
59768       {
59769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59770       };
59771     }
59772   }
59773
59774   jresult = (int)result;
59775   return jresult;
59776 }
59777
59778
59779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59780   int jresult ;
59781   int result;
59782
59783   {
59784     try {
59785       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59786     } catch (std::out_of_range& e) {
59787       {
59788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59789       };
59790     } catch (std::exception& e) {
59791       {
59792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59793       };
59794     } catch (Dali::DaliException e) {
59795       {
59796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59797       };
59798     } catch (...) {
59799       {
59800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59801       };
59802     }
59803   }
59804
59805   jresult = (int)result;
59806   return jresult;
59807 }
59808
59809
59810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59811   int jresult ;
59812   int result;
59813
59814   {
59815     try {
59816       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59817     } catch (std::out_of_range& e) {
59818       {
59819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59820       };
59821     } catch (std::exception& e) {
59822       {
59823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59824       };
59825     } catch (Dali::DaliException e) {
59826       {
59827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59828       };
59829     } catch (...) {
59830       {
59831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59832       };
59833     }
59834   }
59835
59836   jresult = (int)result;
59837   return jresult;
59838 }
59839
59840
59841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59842   int jresult ;
59843   int result;
59844
59845   {
59846     try {
59847       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59848     } catch (std::out_of_range& e) {
59849       {
59850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59851       };
59852     } catch (std::exception& e) {
59853       {
59854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59855       };
59856     } catch (Dali::DaliException e) {
59857       {
59858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59859       };
59860     } catch (...) {
59861       {
59862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59863       };
59864     }
59865   }
59866
59867   jresult = (int)result;
59868   return jresult;
59869 }
59870
59871
59872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59873   int jresult ;
59874   int result;
59875
59876   {
59877     try {
59878       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59879     } catch (std::out_of_range& e) {
59880       {
59881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59882       };
59883     } catch (std::exception& e) {
59884       {
59885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59886       };
59887     } catch (Dali::DaliException e) {
59888       {
59889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59890       };
59891     } catch (...) {
59892       {
59893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59894       };
59895     }
59896   }
59897
59898   jresult = (int)result;
59899   return jresult;
59900 }
59901
59902
59903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59904   int jresult ;
59905   int result;
59906
59907   {
59908     try {
59909       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59910     } catch (std::out_of_range& e) {
59911       {
59912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59913       };
59914     } catch (std::exception& e) {
59915       {
59916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59917       };
59918     } catch (Dali::DaliException e) {
59919       {
59920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59921       };
59922     } catch (...) {
59923       {
59924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59925       };
59926     }
59927   }
59928
59929   jresult = (int)result;
59930   return jresult;
59931 }
59932
59933
59934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59935   int jresult ;
59936   int result;
59937
59938   {
59939     try {
59940       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59941     } catch (std::out_of_range& e) {
59942       {
59943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59944       };
59945     } catch (std::exception& e) {
59946       {
59947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59948       };
59949     } catch (Dali::DaliException e) {
59950       {
59951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59952       };
59953     } catch (...) {
59954       {
59955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59956       };
59957     }
59958   }
59959
59960   jresult = (int)result;
59961   return jresult;
59962 }
59963
59964
59965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59966   int jresult ;
59967   int result;
59968
59969   {
59970     try {
59971       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59972     } catch (std::out_of_range& e) {
59973       {
59974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59975       };
59976     } catch (std::exception& e) {
59977       {
59978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59979       };
59980     } catch (Dali::DaliException e) {
59981       {
59982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59983       };
59984     } catch (...) {
59985       {
59986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59987       };
59988     }
59989   }
59990
59991   jresult = (int)result;
59992   return jresult;
59993 }
59994
59995
59996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59997   int jresult ;
59998   int result;
59999
60000   {
60001     try {
60002       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
60003     } catch (std::out_of_range& e) {
60004       {
60005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60006       };
60007     } catch (std::exception& e) {
60008       {
60009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60010       };
60011     } catch (Dali::DaliException e) {
60012       {
60013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60014       };
60015     } catch (...) {
60016       {
60017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60018       };
60019     }
60020   }
60021
60022   jresult = (int)result;
60023   return jresult;
60024 }
60025
60026
60027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
60028   int jresult ;
60029   int result;
60030
60031   {
60032     try {
60033       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
60034     } catch (std::out_of_range& e) {
60035       {
60036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60037       };
60038     } catch (std::exception& e) {
60039       {
60040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60041       };
60042     } catch (Dali::DaliException e) {
60043       {
60044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60045       };
60046     } catch (...) {
60047       {
60048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60049       };
60050     }
60051   }
60052
60053   jresult = (int)result;
60054   return jresult;
60055 }
60056
60057
60058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60059   int jresult ;
60060   int result;
60061
60062   {
60063     try {
60064       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60065     } catch (std::out_of_range& e) {
60066       {
60067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60068       };
60069     } catch (std::exception& e) {
60070       {
60071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60072       };
60073     } catch (Dali::DaliException e) {
60074       {
60075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60076       };
60077     } catch (...) {
60078       {
60079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60080       };
60081     }
60082   }
60083
60084   jresult = (int)result;
60085   return jresult;
60086 }
60087
60088
60089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60090   int jresult ;
60091   int result;
60092
60093   {
60094     try {
60095       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60096     } catch (std::out_of_range& e) {
60097       {
60098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60099       };
60100     } catch (std::exception& e) {
60101       {
60102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60103       };
60104     } catch (Dali::DaliException e) {
60105       {
60106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60107       };
60108     } catch (...) {
60109       {
60110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60111       };
60112     }
60113   }
60114
60115   jresult = (int)result;
60116   return jresult;
60117 }
60118
60119
60120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60121   int jresult ;
60122   int result;
60123
60124   {
60125     try {
60126       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60127     } catch (std::out_of_range& e) {
60128       {
60129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60130       };
60131     } catch (std::exception& e) {
60132       {
60133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60134       };
60135     } catch (Dali::DaliException e) {
60136       {
60137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60138       };
60139     } catch (...) {
60140       {
60141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60142       };
60143     }
60144   }
60145
60146   jresult = (int)result;
60147   return jresult;
60148 }
60149
60150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60151   int jresult ;
60152   int result;
60153
60154   {
60155     try {
60156       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60157     } catch (std::out_of_range& e) {
60158       {
60159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60160       };
60161     } catch (std::exception& e) {
60162       {
60163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60164       };
60165     } catch (Dali::DaliException e) {
60166       {
60167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60168       };
60169     } catch (...) {
60170       {
60171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60172       };
60173     }
60174   }
60175
60176   jresult = (int)result;
60177   return jresult;
60178 }
60179
60180
60181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60182   int jresult ;
60183   int result;
60184   {
60185     try
60186     {
60187       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60188     } catch (std::out_of_range& e) {
60189       {
60190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60191       };
60192     } catch (std::exception& e) {
60193       {
60194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60195       };
60196     } catch (Dali::DaliException e) {
60197       {
60198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60199       };
60200     } catch (...) {
60201       {
60202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60203       };
60204     }
60205   }
60206
60207   jresult = (int)result;
60208   return jresult;
60209 }
60210
60211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60212   int jresult ;
60213   int result;
60214   {
60215     try
60216     {
60217       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60218     } catch (std::out_of_range& e) {
60219       {
60220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60221       };
60222     } catch (std::exception& e) {
60223       {
60224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60225       };
60226     } catch (Dali::DaliException e) {
60227       {
60228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60229       };
60230     } catch (...) {
60231       {
60232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60233       };
60234     }
60235   }
60236
60237   jresult = (int)result;
60238   return jresult;
60239 }
60240
60241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60242   int jresult ;
60243   int result;
60244   {
60245     try
60246     {
60247       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60248     } catch (std::out_of_range& e) {
60249       {
60250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60251       };
60252     } catch (std::exception& e) {
60253       {
60254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60255       };
60256     } catch (Dali::DaliException e) {
60257       {
60258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60259       };
60260     } catch (...) {
60261       {
60262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60263       };
60264     }
60265   }
60266
60267   jresult = (int)result;
60268   return jresult;
60269 }
60270
60271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
60272   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60273 }
60274
60275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60276   int jresult ;
60277   int result;
60278   {
60279     try
60280     {
60281       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60282     } catch (std::out_of_range& e) {
60283       {
60284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60285       };
60286     } catch (std::exception& e) {
60287       {
60288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60289       };
60290     } catch (Dali::DaliException e) {
60291       {
60292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60293       };
60294     } catch (...) {
60295       {
60296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60297       };
60298     }
60299   }
60300
60301   jresult = (int)result;
60302   return jresult;
60303 }
60304
60305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60306   int jresult ;
60307   int result;
60308   {
60309     try
60310     {
60311       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60312     } catch (std::out_of_range& e) {
60313       {
60314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60315       };
60316     } catch (std::exception& e) {
60317       {
60318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60319       };
60320     } catch (Dali::DaliException e) {
60321       {
60322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60323       };
60324     } catch (...) {
60325       {
60326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60327       };
60328     }
60329   }
60330
60331   jresult = (int)result;
60332   return jresult;
60333 }
60334
60335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60336   int jresult ;
60337   int result;
60338
60339   {
60340     try {
60341       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60342     } catch (std::out_of_range& e) {
60343       {
60344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60345       };
60346     } catch (std::exception& e) {
60347       {
60348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60349       };
60350     } catch (Dali::DaliException e) {
60351       {
60352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60353       };
60354     } catch (...) {
60355       {
60356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60357       };
60358     }
60359   }
60360
60361   jresult = (int)result;
60362   return jresult;
60363 }
60364
60365
60366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60367   int jresult ;
60368   int result;
60369
60370   {
60371     try {
60372       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60373     } catch (std::out_of_range& e) {
60374       {
60375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60376       };
60377     } catch (std::exception& e) {
60378       {
60379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60380       };
60381     } catch (Dali::DaliException e) {
60382       {
60383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60384       };
60385     } catch (...) {
60386       {
60387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60388       };
60389     }
60390   }
60391
60392   jresult = (int)result;
60393   return jresult;
60394 }
60395
60396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60397   int jresult ;
60398   int result;
60399   {
60400     try
60401     {
60402       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60403     } catch (std::out_of_range& e) {
60404       {
60405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60406       };
60407     } catch (std::exception& e) {
60408       {
60409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60410       };
60411     } catch (...) {
60412       {
60413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60414       };
60415     }
60416   }
60417   jresult = (int)result;
60418   return jresult;
60419 }
60420
60421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60422   int jresult ;
60423   int result;
60424   {
60425     try
60426     {
60427       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60428     } catch (std::out_of_range& e) {
60429       {
60430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60431       };
60432     } catch (std::exception& e) {
60433       {
60434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60435       };
60436     } catch (...) {
60437       {
60438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60439       };
60440     }
60441   }
60442   jresult = (int)result;
60443   return jresult;
60444 }
60445
60446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60447   int jresult ;
60448   int result;
60449   {
60450     try
60451     {
60452       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60453     } catch (std::out_of_range& e) {
60454       {
60455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60456       };
60457     } catch (std::exception& e) {
60458       {
60459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60460       };
60461     } catch (...) {
60462       {
60463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60464       };
60465     }
60466   }
60467   jresult = (int)result;
60468   return jresult;
60469 }
60470
60471
60472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60473   int jresult ;
60474   int result;
60475   {
60476     try
60477     {
60478       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60479     } catch (std::out_of_range& e) {
60480       {
60481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60482       };
60483     } catch (std::exception& e) {
60484       {
60485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60486       };
60487     } catch (...) {
60488       {
60489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60490       };
60491     }
60492   }
60493   jresult = (int)result;
60494   return jresult;
60495 }
60496
60497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60498   int jresult ;
60499   int result;
60500   {
60501     try
60502     {
60503       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60504     } catch (std::out_of_range& e) {
60505       {
60506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60507       };
60508     } catch (std::exception& e) {
60509       {
60510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60511       };
60512     } catch (...) {
60513       {
60514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60515       };
60516     }
60517   }
60518   jresult = (int)result;
60519   return jresult;
60520 }
60521
60522
60523
60524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60525   int jresult ;
60526   int result;
60527
60528   {
60529     try {
60530       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60531     } catch (std::out_of_range& e) {
60532       {
60533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60534       };
60535     } catch (std::exception& e) {
60536       {
60537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60538       };
60539     } catch (Dali::DaliException e) {
60540       {
60541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60542       };
60543     } catch (...) {
60544       {
60545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60546       };
60547     }
60548   }
60549
60550   jresult = (int)result;
60551   return jresult;
60552 }
60553
60554
60555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60556   int jresult ;
60557   int result;
60558
60559   {
60560     try {
60561       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60562     } catch (std::out_of_range& e) {
60563       {
60564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60565       };
60566     } catch (std::exception& e) {
60567       {
60568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60569       };
60570     } catch (Dali::DaliException e) {
60571       {
60572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60573       };
60574     } catch (...) {
60575       {
60576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60577       };
60578     }
60579   }
60580
60581   jresult = (int)result;
60582   return jresult;
60583 }
60584
60585
60586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60587   int jresult ;
60588   int result;
60589
60590   {
60591     try {
60592       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60593     } catch (std::out_of_range& e) {
60594       {
60595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60596       };
60597     } catch (std::exception& e) {
60598       {
60599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60600       };
60601     } catch (Dali::DaliException e) {
60602       {
60603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60604       };
60605     } catch (...) {
60606       {
60607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60608       };
60609     }
60610   }
60611
60612   jresult = (int)result;
60613   return jresult;
60614 }
60615
60616
60617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60618   int jresult ;
60619   int result;
60620
60621   {
60622     try {
60623       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60624     } catch (std::out_of_range& e) {
60625       {
60626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60627       };
60628     } catch (std::exception& e) {
60629       {
60630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60631       };
60632     } catch (Dali::DaliException e) {
60633       {
60634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60635       };
60636     } catch (...) {
60637       {
60638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60639       };
60640     }
60641   }
60642
60643   jresult = (int)result;
60644   return jresult;
60645 }
60646
60647
60648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60649   int jresult ;
60650   int result;
60651
60652   {
60653     try {
60654       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60655     } catch (std::out_of_range& e) {
60656       {
60657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60658       };
60659     } catch (std::exception& e) {
60660       {
60661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60662       };
60663     } catch (Dali::DaliException e) {
60664       {
60665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60666       };
60667     } catch (...) {
60668       {
60669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60670       };
60671     }
60672   }
60673
60674   jresult = (int)result;
60675   return jresult;
60676 }
60677
60678
60679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60680   int jresult ;
60681   int result;
60682
60683   {
60684     try {
60685       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60686     } catch (std::out_of_range& e) {
60687       {
60688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60689       };
60690     } catch (std::exception& e) {
60691       {
60692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60693       };
60694     } catch (Dali::DaliException e) {
60695       {
60696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60701       };
60702     }
60703   }
60704
60705   jresult = (int)result;
60706   return jresult;
60707 }
60708
60709
60710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60711   int jresult ;
60712   int result;
60713
60714   {
60715     try {
60716       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60717     } catch (std::out_of_range& e) {
60718       {
60719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60720       };
60721     } catch (std::exception& e) {
60722       {
60723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60724       };
60725     } catch (Dali::DaliException e) {
60726       {
60727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60728       };
60729     } catch (...) {
60730       {
60731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60732       };
60733     }
60734   }
60735
60736   jresult = (int)result;
60737   return jresult;
60738 }
60739
60740 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60741   int jresult ;
60742   int result;
60743
60744   {
60745     try {
60746       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60747     } catch (std::out_of_range& e) {
60748       {
60749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60750       };
60751     } catch (std::exception& e) {
60752       {
60753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60754       };
60755     } catch (...) {
60756       {
60757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60758       };
60759     }
60760   }
60761   jresult = (int)result;
60762   return jresult;
60763 }
60764
60765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60766   int jresult ;
60767   int result;
60768
60769   {
60770     try {
60771       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60772     } catch (std::out_of_range& e) {
60773       {
60774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60775       };
60776     } catch (std::exception& e) {
60777       {
60778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60779       };
60780     } catch (Dali::DaliException e) {
60781       {
60782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60783       };
60784     } catch (...) {
60785       {
60786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60787       };
60788     }
60789   }
60790
60791   jresult = (int)result;
60792   return jresult;
60793 }
60794
60795
60796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60797   int jresult ;
60798   int result;
60799
60800   {
60801     try {
60802       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60803     } catch (std::out_of_range& e) {
60804       {
60805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60806       };
60807     } catch (std::exception& e) {
60808       {
60809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60810       };
60811     } catch (Dali::DaliException e) {
60812       {
60813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60814       };
60815     } catch (...) {
60816       {
60817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60818       };
60819     }
60820   }
60821
60822   jresult = (int)result;
60823   return jresult;
60824 }
60825
60826
60827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60828   int jresult ;
60829   int result;
60830
60831   {
60832     try {
60833       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60834     } catch (std::out_of_range& e) {
60835       {
60836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60837       };
60838     } catch (std::exception& e) {
60839       {
60840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60841       };
60842     } catch (Dali::DaliException e) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60845       };
60846     } catch (...) {
60847       {
60848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60849       };
60850     }
60851   }
60852
60853   jresult = (int)result;
60854   return jresult;
60855 }
60856
60857
60858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60859   int jresult ;
60860   int result;
60861
60862   {
60863     try {
60864       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60865     } catch (std::out_of_range& e) {
60866       {
60867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60868       };
60869     } catch (std::exception& e) {
60870       {
60871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60872       };
60873     } catch (Dali::DaliException e) {
60874       {
60875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60876       };
60877     } catch (...) {
60878       {
60879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60880       };
60881     }
60882   }
60883
60884   jresult = (int)result;
60885   return jresult;
60886 }
60887
60888
60889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60890   int jresult ;
60891   int result;
60892
60893   {
60894     try {
60895       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60896     } catch (std::out_of_range& e) {
60897       {
60898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (std::exception& e) {
60901       {
60902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60903       };
60904     } catch (Dali::DaliException e) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60907       };
60908     } catch (...) {
60909       {
60910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60911       };
60912     }
60913   }
60914
60915   jresult = (int)result;
60916   return jresult;
60917 }
60918
60919
60920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60921   int jresult ;
60922   int result;
60923
60924   {
60925     try {
60926       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60927     } catch (std::out_of_range& e) {
60928       {
60929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (std::exception& e) {
60932       {
60933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60934       };
60935     } catch (Dali::DaliException e) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60938       };
60939     } catch (...) {
60940       {
60941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60942       };
60943     }
60944   }
60945
60946   jresult = (int)result;
60947   return jresult;
60948 }
60949
60950
60951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60952   int jresult ;
60953   int result;
60954
60955   {
60956     try {
60957       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60958     } catch (std::out_of_range& e) {
60959       {
60960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60961       };
60962     } catch (std::exception& e) {
60963       {
60964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60965       };
60966     } catch (Dali::DaliException e) {
60967       {
60968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60969       };
60970     } catch (...) {
60971       {
60972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60973       };
60974     }
60975   }
60976
60977   jresult = (int)result;
60978   return jresult;
60979 }
60980
60981
60982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60983   int jresult ;
60984   int result;
60985
60986   {
60987     try {
60988       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60989     } catch (std::out_of_range& e) {
60990       {
60991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (std::exception& e) {
60994       {
60995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60996       };
60997     } catch (Dali::DaliException e) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61000       };
61001     } catch (...) {
61002       {
61003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61004       };
61005     }
61006   }
61007
61008   jresult = (int)result;
61009   return jresult;
61010 }
61011
61012
61013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
61014   int jresult ;
61015   int result;
61016
61017   {
61018     try {
61019       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
61020     } catch (std::out_of_range& e) {
61021       {
61022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (std::exception& e) {
61025       {
61026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61027       };
61028     } catch (Dali::DaliException e) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61031       };
61032     } catch (...) {
61033       {
61034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61035       };
61036     }
61037   }
61038
61039   jresult = (int)result;
61040   return jresult;
61041 }
61042
61043
61044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
61045   int jresult ;
61046   int result;
61047
61048   {
61049     try {
61050       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61051     } catch (std::out_of_range& e) {
61052       {
61053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61054       };
61055     } catch (std::exception& e) {
61056       {
61057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61058       };
61059     } catch (Dali::DaliException e) {
61060       {
61061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61062       };
61063     } catch (...) {
61064       {
61065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61066       };
61067     }
61068   }
61069
61070   jresult = (int)result;
61071   return jresult;
61072 }
61073
61074
61075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61076   int jresult ;
61077   int result;
61078
61079   {
61080     try {
61081       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61082     } catch (std::out_of_range& e) {
61083       {
61084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (std::exception& e) {
61087       {
61088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61089       };
61090     } catch (Dali::DaliException e) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61093       };
61094     } catch (...) {
61095       {
61096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61097       };
61098     }
61099   }
61100
61101   jresult = (int)result;
61102   return jresult;
61103 }
61104
61105
61106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61107   int jresult ;
61108   int result;
61109
61110   {
61111     try {
61112       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61113     } catch (std::out_of_range& e) {
61114       {
61115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (std::exception& e) {
61118       {
61119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61120       };
61121     } catch (Dali::DaliException e) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61124       };
61125     } catch (...) {
61126       {
61127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61128       };
61129     }
61130   }
61131
61132   jresult = (int)result;
61133   return jresult;
61134 }
61135
61136
61137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61138   int jresult ;
61139   int result;
61140
61141   {
61142     try {
61143       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61144     } catch (std::out_of_range& e) {
61145       {
61146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61147       };
61148     } catch (std::exception& e) {
61149       {
61150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61151       };
61152     } catch (Dali::DaliException e) {
61153       {
61154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61155       };
61156     } catch (...) {
61157       {
61158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61159       };
61160     }
61161   }
61162
61163   jresult = (int)result;
61164   return jresult;
61165 }
61166
61167
61168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61169   int jresult ;
61170   int result;
61171
61172   {
61173     try {
61174       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61175     } catch (std::out_of_range& e) {
61176       {
61177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61178       };
61179     } catch (std::exception& e) {
61180       {
61181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61182       };
61183     } catch (Dali::DaliException e) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61186       };
61187     } catch (...) {
61188       {
61189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61190       };
61191     }
61192   }
61193
61194   jresult = (int)result;
61195   return jresult;
61196 }
61197
61198
61199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61200   int jresult ;
61201   int result;
61202
61203   {
61204     try {
61205       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61206     } catch (std::out_of_range& e) {
61207       {
61208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61209       };
61210     } catch (std::exception& e) {
61211       {
61212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61213       };
61214     } catch (Dali::DaliException e) {
61215       {
61216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61217       };
61218     } catch (...) {
61219       {
61220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61221       };
61222     }
61223   }
61224
61225   jresult = (int)result;
61226   return jresult;
61227 }
61228
61229
61230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61231   int jresult ;
61232   int result;
61233
61234   {
61235     try {
61236       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61237     } catch (std::out_of_range& e) {
61238       {
61239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61240       };
61241     } catch (std::exception& e) {
61242       {
61243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61244       };
61245     } catch (Dali::DaliException e) {
61246       {
61247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61248       };
61249     } catch (...) {
61250       {
61251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61252       };
61253     }
61254   }
61255
61256   jresult = (int)result;
61257   return jresult;
61258 }
61259
61260
61261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61262   int jresult ;
61263   int result;
61264
61265   {
61266     try {
61267       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61268     } catch (std::out_of_range& e) {
61269       {
61270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61271       };
61272     } catch (std::exception& e) {
61273       {
61274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61275       };
61276     } catch (Dali::DaliException e) {
61277       {
61278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61279       };
61280     } catch (...) {
61281       {
61282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61283       };
61284     }
61285   }
61286
61287   jresult = (int)result;
61288   return jresult;
61289 }
61290
61291
61292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61293   int jresult ;
61294   int result;
61295
61296   {
61297     try {
61298       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61299     } catch (std::out_of_range& e) {
61300       {
61301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61302       };
61303     } catch (std::exception& e) {
61304       {
61305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61306       };
61307     } catch (Dali::DaliException e) {
61308       {
61309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61310       };
61311     } catch (...) {
61312       {
61313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61314       };
61315     }
61316   }
61317
61318   jresult = (int)result;
61319   return jresult;
61320 }
61321
61322
61323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61324   int jresult ;
61325   int result;
61326
61327   {
61328     try {
61329       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61330     } catch (std::out_of_range& e) {
61331       {
61332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61333       };
61334     } catch (std::exception& e) {
61335       {
61336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61337       };
61338     } catch (Dali::DaliException e) {
61339       {
61340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61341       };
61342     } catch (...) {
61343       {
61344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61345       };
61346     }
61347   }
61348
61349   jresult = (int)result;
61350   return jresult;
61351 }
61352
61353
61354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61355   int jresult ;
61356   int result;
61357
61358   {
61359     try {
61360       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61361     } catch (std::out_of_range& e) {
61362       {
61363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61364       };
61365     } catch (std::exception& e) {
61366       {
61367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61368       };
61369     } catch (Dali::DaliException e) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61372       };
61373     } catch (...) {
61374       {
61375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61376       };
61377     }
61378   }
61379
61380   jresult = (int)result;
61381   return jresult;
61382 }
61383
61384
61385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61386   int jresult ;
61387   int result;
61388
61389   {
61390     try {
61391       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61392     } catch (std::out_of_range& e) {
61393       {
61394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61395       };
61396     } catch (std::exception& e) {
61397       {
61398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61399       };
61400     } catch (Dali::DaliException e) {
61401       {
61402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61403       };
61404     } catch (...) {
61405       {
61406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61407       };
61408     }
61409   }
61410
61411   jresult = (int)result;
61412   return jresult;
61413 }
61414
61415
61416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61417   int jresult ;
61418   int result;
61419
61420   {
61421     try {
61422       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61423     } catch (std::out_of_range& e) {
61424       {
61425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61426       };
61427     } catch (std::exception& e) {
61428       {
61429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61430       };
61431     } catch (Dali::DaliException e) {
61432       {
61433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61434       };
61435     } catch (...) {
61436       {
61437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61438       };
61439     }
61440   }
61441
61442   jresult = (int)result;
61443   return jresult;
61444 }
61445
61446
61447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61448   int jresult ;
61449   int result;
61450
61451   {
61452     try {
61453       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61454     } catch (std::out_of_range& e) {
61455       {
61456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61457       };
61458     } catch (std::exception& e) {
61459       {
61460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61461       };
61462     } catch (Dali::DaliException e) {
61463       {
61464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61465       };
61466     } catch (...) {
61467       {
61468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61469       };
61470     }
61471   }
61472
61473   jresult = (int)result;
61474   return jresult;
61475 }
61476
61477
61478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61479   int jresult ;
61480   int result;
61481
61482   {
61483     try {
61484       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61485     } catch (std::out_of_range& e) {
61486       {
61487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61488       };
61489     } catch (std::exception& e) {
61490       {
61491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61492       };
61493     } catch (Dali::DaliException e) {
61494       {
61495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61496       };
61497     } catch (...) {
61498       {
61499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61500       };
61501     }
61502   }
61503
61504   jresult = (int)result;
61505   return jresult;
61506 }
61507
61508
61509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61510   int jresult ;
61511   int result;
61512
61513   {
61514     try {
61515       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61516     } catch (std::out_of_range& e) {
61517       {
61518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61519       };
61520     } catch (std::exception& e) {
61521       {
61522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61523       };
61524     } catch (Dali::DaliException e) {
61525       {
61526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61527       };
61528     } catch (...) {
61529       {
61530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61531       };
61532     }
61533   }
61534
61535   jresult = (int)result;
61536   return jresult;
61537 }
61538
61539
61540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61541   int jresult ;
61542   int result;
61543
61544   {
61545     try {
61546       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61547     } catch (std::out_of_range& e) {
61548       {
61549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61550       };
61551     } catch (std::exception& e) {
61552       {
61553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61554       };
61555     } catch (Dali::DaliException e) {
61556       {
61557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61558       };
61559     } catch (...) {
61560       {
61561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61562       };
61563     }
61564   }
61565
61566   jresult = (int)result;
61567   return jresult;
61568 }
61569
61570
61571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61572   int jresult ;
61573   int result;
61574
61575   {
61576     try {
61577       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61578     } catch (std::out_of_range& e) {
61579       {
61580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61581       };
61582     } catch (std::exception& e) {
61583       {
61584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61585       };
61586     } catch (Dali::DaliException e) {
61587       {
61588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61589       };
61590     } catch (...) {
61591       {
61592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61593       };
61594     }
61595   }
61596
61597   jresult = (int)result;
61598   return jresult;
61599 }
61600
61601
61602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61603   int jresult ;
61604   int result;
61605
61606   {
61607     try {
61608       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61609     } catch (std::out_of_range& e) {
61610       {
61611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61612       };
61613     } catch (std::exception& e) {
61614       {
61615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61616       };
61617     } catch (Dali::DaliException e) {
61618       {
61619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61620       };
61621     } catch (...) {
61622       {
61623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61624       };
61625     }
61626   }
61627
61628   jresult = (int)result;
61629   return jresult;
61630 }
61631
61632
61633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61634   void * jresult ;
61635   Dali::Toolkit::Builder *result = 0 ;
61636
61637   {
61638     try {
61639       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61640     } catch (std::out_of_range& e) {
61641       {
61642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61643       };
61644     } catch (std::exception& e) {
61645       {
61646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61647       };
61648     } catch (Dali::DaliException e) {
61649       {
61650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61651       };
61652     } catch (...) {
61653       {
61654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61655       };
61656     }
61657   }
61658
61659   jresult = (void *)result;
61660   return jresult;
61661 }
61662
61663
61664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61665   void * jresult ;
61666   Dali::Toolkit::Builder result;
61667
61668   {
61669     try {
61670       result = Dali::Toolkit::Builder::New();
61671     } catch (std::out_of_range& e) {
61672       {
61673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61674       };
61675     } catch (std::exception& e) {
61676       {
61677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61678       };
61679     } catch (Dali::DaliException e) {
61680       {
61681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61682       };
61683     } catch (...) {
61684       {
61685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61686       };
61687     }
61688   }
61689
61690   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61691   return jresult;
61692 }
61693
61694
61695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61696   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61697
61698   arg1 = (Dali::Toolkit::Builder *)jarg1;
61699   {
61700     try {
61701       delete arg1;
61702     } catch (std::out_of_range& e) {
61703       {
61704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61705       };
61706     } catch (std::exception& e) {
61707       {
61708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61709       };
61710     } catch (Dali::DaliException e) {
61711       {
61712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61713       };
61714     } catch (...) {
61715       {
61716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61717       };
61718     }
61719   }
61720
61721 }
61722
61723
61724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61725   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61726   std::string *arg2 = 0 ;
61727   Dali::Toolkit::Builder::UIFormat arg3 ;
61728
61729   arg1 = (Dali::Toolkit::Builder *)jarg1;
61730   if (!jarg2) {
61731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61732     return ;
61733   }
61734   std::string arg2_str(jarg2);
61735   arg2 = &arg2_str;
61736   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61737   {
61738     try {
61739       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61740     } catch (std::out_of_range& e) {
61741       {
61742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61743       };
61744     } catch (std::exception& e) {
61745       {
61746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61747       };
61748     } catch (Dali::DaliException e) {
61749       {
61750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61751       };
61752     } catch (...) {
61753       {
61754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61755       };
61756     }
61757   }
61758
61759
61760   //argout typemap for const std::string&
61761
61762 }
61763
61764
61765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61766   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61767   std::string *arg2 = 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   {
61777     try {
61778       (arg1)->LoadFromString((std::string const &)*arg2);
61779     } catch (std::out_of_range& e) {
61780       {
61781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61782       };
61783     } catch (std::exception& e) {
61784       {
61785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61786       };
61787     } catch (Dali::DaliException e) {
61788       {
61789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61790       };
61791     } catch (...) {
61792       {
61793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61794       };
61795     }
61796   }
61797
61798
61799   //argout typemap for const std::string&
61800
61801 }
61802
61803
61804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61805   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61806   Dali::Property::Map *arg2 = 0 ;
61807
61808   arg1 = (Dali::Toolkit::Builder *)jarg1;
61809   arg2 = (Dali::Property::Map *)jarg2;
61810   if (!arg2) {
61811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61812     return ;
61813   }
61814   {
61815     try {
61816       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61817     } catch (std::out_of_range& e) {
61818       {
61819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61820       };
61821     } catch (std::exception& e) {
61822       {
61823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61824       };
61825     } catch (Dali::DaliException e) {
61826       {
61827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61828       };
61829     } catch (...) {
61830       {
61831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61832       };
61833     }
61834   }
61835
61836 }
61837
61838
61839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61840   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61841   std::string *arg2 = 0 ;
61842   Dali::Property::Value *arg3 = 0 ;
61843
61844   arg1 = (Dali::Toolkit::Builder *)jarg1;
61845   if (!jarg2) {
61846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61847     return ;
61848   }
61849   std::string arg2_str(jarg2);
61850   arg2 = &arg2_str;
61851   arg3 = (Dali::Property::Value *)jarg3;
61852   if (!arg3) {
61853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61854     return ;
61855   }
61856   {
61857     try {
61858       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61859     } catch (std::out_of_range& e) {
61860       {
61861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61862       };
61863     } catch (std::exception& e) {
61864       {
61865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61866       };
61867     } catch (Dali::DaliException e) {
61868       {
61869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61870       };
61871     } catch (...) {
61872       {
61873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61874       };
61875     }
61876   }
61877
61878
61879   //argout typemap for const std::string&
61880
61881 }
61882
61883
61884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61885   void * jresult ;
61886   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61887   Dali::Property::Map *result = 0 ;
61888
61889   arg1 = (Dali::Toolkit::Builder *)jarg1;
61890   {
61891     try {
61892       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61893     } catch (std::out_of_range& e) {
61894       {
61895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61896       };
61897     } catch (std::exception& e) {
61898       {
61899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61900       };
61901     } catch (Dali::DaliException e) {
61902       {
61903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61904       };
61905     } catch (...) {
61906       {
61907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61908       };
61909     }
61910   }
61911
61912   jresult = (void *)result;
61913   return jresult;
61914 }
61915
61916
61917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61918   void * jresult ;
61919   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61920   std::string *arg2 = 0 ;
61921   Dali::Property::Value *result = 0 ;
61922
61923   arg1 = (Dali::Toolkit::Builder *)jarg1;
61924   if (!jarg2) {
61925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61926     return 0;
61927   }
61928   std::string arg2_str(jarg2);
61929   arg2 = &arg2_str;
61930   {
61931     try {
61932       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61933     } catch (std::out_of_range& e) {
61934       {
61935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61936       };
61937     } catch (std::exception& e) {
61938       {
61939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61940       };
61941     } catch (Dali::DaliException e) {
61942       {
61943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61944       };
61945     } catch (...) {
61946       {
61947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61948       };
61949     }
61950   }
61951
61952   jresult = (void *)result;
61953
61954   //argout typemap for const std::string&
61955
61956   return jresult;
61957 }
61958
61959
61960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61961   void * jresult ;
61962   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61963   std::string *arg2 = 0 ;
61964   Dali::Animation result;
61965
61966   arg1 = (Dali::Toolkit::Builder *)jarg1;
61967   if (!jarg2) {
61968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61969     return 0;
61970   }
61971   std::string arg2_str(jarg2);
61972   arg2 = &arg2_str;
61973   {
61974     try {
61975       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61976     } catch (std::out_of_range& e) {
61977       {
61978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61979       };
61980     } catch (std::exception& e) {
61981       {
61982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61983       };
61984     } catch (Dali::DaliException e) {
61985       {
61986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61987       };
61988     } catch (...) {
61989       {
61990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61991       };
61992     }
61993   }
61994
61995   jresult = new Dali::Animation((const Dali::Animation &)result);
61996
61997   //argout typemap for const std::string&
61998
61999   return jresult;
62000 }
62001
62002
62003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62004   void * jresult ;
62005   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62006   std::string *arg2 = 0 ;
62007   Dali::Property::Map *arg3 = 0 ;
62008   Dali::Animation result;
62009
62010   arg1 = (Dali::Toolkit::Builder *)jarg1;
62011   if (!jarg2) {
62012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62013     return 0;
62014   }
62015   std::string arg2_str(jarg2);
62016   arg2 = &arg2_str;
62017   arg3 = (Dali::Property::Map *)jarg3;
62018   if (!arg3) {
62019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62020     return 0;
62021   }
62022   {
62023     try {
62024       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62025     } catch (std::out_of_range& e) {
62026       {
62027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62028       };
62029     } catch (std::exception& e) {
62030       {
62031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62032       };
62033     } catch (Dali::DaliException e) {
62034       {
62035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62036       };
62037     } catch (...) {
62038       {
62039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62040       };
62041     }
62042   }
62043
62044   jresult = new Dali::Animation((const Dali::Animation &)result);
62045
62046   //argout typemap for const std::string&
62047
62048   return jresult;
62049 }
62050
62051
62052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62053   void * jresult ;
62054   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62055   std::string *arg2 = 0 ;
62056   Dali::Actor arg3 ;
62057   Dali::Actor *argp3 ;
62058   Dali::Animation result;
62059
62060   arg1 = (Dali::Toolkit::Builder *)jarg1;
62061   if (!jarg2) {
62062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62063     return 0;
62064   }
62065   std::string arg2_str(jarg2);
62066   arg2 = &arg2_str;
62067   argp3 = (Dali::Actor *)jarg3;
62068   if (!argp3) {
62069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62070     return 0;
62071   }
62072   arg3 = *argp3;
62073   {
62074     try {
62075       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62076     } catch (std::out_of_range& e) {
62077       {
62078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62079       };
62080     } catch (std::exception& e) {
62081       {
62082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62083       };
62084     } catch (Dali::DaliException e) {
62085       {
62086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62087       };
62088     } catch (...) {
62089       {
62090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62091       };
62092     }
62093   }
62094
62095   jresult = new Dali::Animation((const Dali::Animation &)result);
62096
62097   //argout typemap for const std::string&
62098
62099   return jresult;
62100 }
62101
62102
62103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62104   void * jresult ;
62105   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62106   std::string *arg2 = 0 ;
62107   Dali::Property::Map *arg3 = 0 ;
62108   Dali::Actor arg4 ;
62109   Dali::Actor *argp4 ;
62110   Dali::Animation result;
62111
62112   arg1 = (Dali::Toolkit::Builder *)jarg1;
62113   if (!jarg2) {
62114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62115     return 0;
62116   }
62117   std::string arg2_str(jarg2);
62118   arg2 = &arg2_str;
62119   arg3 = (Dali::Property::Map *)jarg3;
62120   if (!arg3) {
62121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62122     return 0;
62123   }
62124   argp4 = (Dali::Actor *)jarg4;
62125   if (!argp4) {
62126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62127     return 0;
62128   }
62129   arg4 = *argp4;
62130   {
62131     try {
62132       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62133     } catch (std::out_of_range& e) {
62134       {
62135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62136       };
62137     } catch (std::exception& e) {
62138       {
62139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62140       };
62141     } catch (Dali::DaliException e) {
62142       {
62143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62144       };
62145     } catch (...) {
62146       {
62147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62148       };
62149     }
62150   }
62151
62152   jresult = new Dali::Animation((const Dali::Animation &)result);
62153
62154   //argout typemap for const std::string&
62155
62156   return jresult;
62157 }
62158
62159
62160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62161   void * jresult ;
62162   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62163   std::string *arg2 = 0 ;
62164   Dali::BaseHandle result;
62165
62166   arg1 = (Dali::Toolkit::Builder *)jarg1;
62167   if (!jarg2) {
62168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62169     return 0;
62170   }
62171   std::string arg2_str(jarg2);
62172   arg2 = &arg2_str;
62173   {
62174     try {
62175       result = (arg1)->Create((std::string const &)*arg2);
62176     } catch (std::out_of_range& e) {
62177       {
62178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62179       };
62180     } catch (std::exception& e) {
62181       {
62182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62183       };
62184     } catch (Dali::DaliException e) {
62185       {
62186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62187       };
62188     } catch (...) {
62189       {
62190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62191       };
62192     }
62193   }
62194
62195   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62196
62197   //argout typemap for const std::string&
62198
62199   return jresult;
62200 }
62201
62202
62203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62204   void * jresult ;
62205   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62206   std::string *arg2 = 0 ;
62207   Dali::Property::Map *arg3 = 0 ;
62208   Dali::BaseHandle result;
62209
62210   arg1 = (Dali::Toolkit::Builder *)jarg1;
62211   if (!jarg2) {
62212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62213     return 0;
62214   }
62215   std::string arg2_str(jarg2);
62216   arg2 = &arg2_str;
62217   arg3 = (Dali::Property::Map *)jarg3;
62218   if (!arg3) {
62219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62220     return 0;
62221   }
62222   {
62223     try {
62224       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62225     } catch (std::out_of_range& e) {
62226       {
62227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62228       };
62229     } catch (std::exception& e) {
62230       {
62231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62232       };
62233     } catch (Dali::DaliException e) {
62234       {
62235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62236       };
62237     } catch (...) {
62238       {
62239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62240       };
62241     }
62242   }
62243
62244   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62245
62246   //argout typemap for const std::string&
62247
62248   return jresult;
62249 }
62250
62251
62252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62253   void * jresult ;
62254   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62255   std::string *arg2 = 0 ;
62256   Dali::BaseHandle result;
62257
62258   arg1 = (Dali::Toolkit::Builder *)jarg1;
62259   if (!jarg2) {
62260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62261     return 0;
62262   }
62263   std::string arg2_str(jarg2);
62264   arg2 = &arg2_str;
62265   {
62266     try {
62267       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62268     } catch (std::out_of_range& e) {
62269       {
62270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62271       };
62272     } catch (std::exception& e) {
62273       {
62274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62275       };
62276     } catch (Dali::DaliException e) {
62277       {
62278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62279       };
62280     } catch (...) {
62281       {
62282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62283       };
62284     }
62285   }
62286
62287   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62288
62289   //argout typemap for const std::string&
62290
62291   return jresult;
62292 }
62293
62294
62295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62296   unsigned int jresult ;
62297   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62298   std::string *arg2 = 0 ;
62299   Dali::Handle *arg3 = 0 ;
62300   bool result;
62301
62302   arg1 = (Dali::Toolkit::Builder *)jarg1;
62303   if (!jarg2) {
62304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62305     return 0;
62306   }
62307   std::string arg2_str(jarg2);
62308   arg2 = &arg2_str;
62309   arg3 = (Dali::Handle *)jarg3;
62310   if (!arg3) {
62311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62312     return 0;
62313   }
62314   {
62315     try {
62316       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62317     } catch (std::out_of_range& e) {
62318       {
62319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62320       };
62321     } catch (std::exception& e) {
62322       {
62323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62324       };
62325     } catch (Dali::DaliException e) {
62326       {
62327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62328       };
62329     } catch (...) {
62330       {
62331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62332       };
62333     }
62334   }
62335
62336   jresult = result;
62337
62338   //argout typemap for const std::string&
62339
62340   return jresult;
62341 }
62342
62343
62344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62345   unsigned int jresult ;
62346   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62347   Dali::Handle *arg2 = 0 ;
62348   std::string *arg3 = 0 ;
62349   bool result;
62350
62351   arg1 = (Dali::Toolkit::Builder *)jarg1;
62352   arg2 = (Dali::Handle *)jarg2;
62353   if (!arg2) {
62354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62355     return 0;
62356   }
62357   if (!jarg3) {
62358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62359     return 0;
62360   }
62361   std::string arg3_str(jarg3);
62362   arg3 = &arg3_str;
62363   {
62364     try {
62365       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62366     } catch (std::out_of_range& e) {
62367       {
62368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62369       };
62370     } catch (std::exception& e) {
62371       {
62372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62373       };
62374     } catch (Dali::DaliException e) {
62375       {
62376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62377       };
62378     } catch (...) {
62379       {
62380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62381       };
62382     }
62383   }
62384
62385   jresult = result;
62386
62387   //argout typemap for const std::string&
62388
62389   return jresult;
62390 }
62391
62392
62393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62394   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62395   Dali::Actor arg2 ;
62396   Dali::Actor *argp2 ;
62397
62398   arg1 = (Dali::Toolkit::Builder *)jarg1;
62399   argp2 = (Dali::Actor *)jarg2;
62400   if (!argp2) {
62401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62402     return ;
62403   }
62404   arg2 = *argp2;
62405   {
62406     try {
62407       (arg1)->AddActors(arg2);
62408     } catch (std::out_of_range& e) {
62409       {
62410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62411       };
62412     } catch (std::exception& e) {
62413       {
62414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62415       };
62416     } catch (Dali::DaliException e) {
62417       {
62418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62419       };
62420     } catch (...) {
62421       {
62422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62423       };
62424     }
62425   }
62426
62427 }
62428
62429
62430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62431   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62432   std::string *arg2 = 0 ;
62433   Dali::Actor arg3 ;
62434   Dali::Actor *argp3 ;
62435
62436   arg1 = (Dali::Toolkit::Builder *)jarg1;
62437   if (!jarg2) {
62438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62439     return ;
62440   }
62441   std::string arg2_str(jarg2);
62442   arg2 = &arg2_str;
62443   argp3 = (Dali::Actor *)jarg3;
62444   if (!argp3) {
62445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62446     return ;
62447   }
62448   arg3 = *argp3;
62449   {
62450     try {
62451       (arg1)->AddActors((std::string const &)*arg2,arg3);
62452     } catch (std::out_of_range& e) {
62453       {
62454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62455       };
62456     } catch (std::exception& e) {
62457       {
62458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62459       };
62460     } catch (Dali::DaliException e) {
62461       {
62462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62463       };
62464     } catch (...) {
62465       {
62466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62467       };
62468     }
62469   }
62470
62471
62472   //argout typemap for const std::string&
62473
62474 }
62475
62476
62477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62478   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62479   std::string *arg2 = 0 ;
62480
62481   arg1 = (Dali::Toolkit::Builder *)jarg1;
62482   if (!jarg2) {
62483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62484     return ;
62485   }
62486   std::string arg2_str(jarg2);
62487   arg2 = &arg2_str;
62488   {
62489     try {
62490       (arg1)->CreateRenderTask((std::string const &)*arg2);
62491     } catch (std::out_of_range& e) {
62492       {
62493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62494       };
62495     } catch (std::exception& e) {
62496       {
62497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62498       };
62499     } catch (Dali::DaliException e) {
62500       {
62501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62502       };
62503     } catch (...) {
62504       {
62505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62506       };
62507     }
62508   }
62509
62510
62511   //argout typemap for const std::string&
62512
62513 }
62514
62515
62516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62517   void * jresult ;
62518   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62519   std::string *arg2 = 0 ;
62520   Dali::FrameBufferImage result;
62521
62522   arg1 = (Dali::Toolkit::Builder *)jarg1;
62523   if (!jarg2) {
62524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62525     return 0;
62526   }
62527   std::string arg2_str(jarg2);
62528   arg2 = &arg2_str;
62529   {
62530     try {
62531       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (Dali::DaliException e) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62547       };
62548     }
62549   }
62550
62551   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62552
62553   //argout typemap for const std::string&
62554
62555   return jresult;
62556 }
62557
62558
62559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62560   void * jresult ;
62561   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62562   std::string *arg2 = 0 ;
62563   Dali::Path result;
62564
62565   arg1 = (Dali::Toolkit::Builder *)jarg1;
62566   if (!jarg2) {
62567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62568     return 0;
62569   }
62570   std::string arg2_str(jarg2);
62571   arg2 = &arg2_str;
62572   {
62573     try {
62574       result = (arg1)->GetPath((std::string const &)*arg2);
62575     } catch (std::out_of_range& e) {
62576       {
62577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62578       };
62579     } catch (std::exception& e) {
62580       {
62581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62582       };
62583     } catch (Dali::DaliException e) {
62584       {
62585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62586       };
62587     } catch (...) {
62588       {
62589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62590       };
62591     }
62592   }
62593
62594   jresult = new Dali::Path((const Dali::Path &)result);
62595
62596   //argout typemap for const std::string&
62597
62598   return jresult;
62599 }
62600
62601
62602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62603   void * jresult ;
62604   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62605   std::string *arg2 = 0 ;
62606   Dali::PathConstrainer result;
62607
62608   arg1 = (Dali::Toolkit::Builder *)jarg1;
62609   if (!jarg2) {
62610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62611     return 0;
62612   }
62613   std::string arg2_str(jarg2);
62614   arg2 = &arg2_str;
62615   {
62616     try {
62617       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62618     } catch (std::out_of_range& e) {
62619       {
62620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62621       };
62622     } catch (std::exception& e) {
62623       {
62624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62625       };
62626     } catch (Dali::DaliException e) {
62627       {
62628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62629       };
62630     } catch (...) {
62631       {
62632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62633       };
62634     }
62635   }
62636
62637   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62638
62639   //argout typemap for const std::string&
62640
62641   return jresult;
62642 }
62643
62644
62645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62646   void * jresult ;
62647   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62648   std::string *arg2 = 0 ;
62649   Dali::LinearConstrainer result;
62650
62651   arg1 = (Dali::Toolkit::Builder *)jarg1;
62652   if (!jarg2) {
62653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62654     return 0;
62655   }
62656   std::string arg2_str(jarg2);
62657   arg2 = &arg2_str;
62658   {
62659     try {
62660       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62661     } catch (std::out_of_range& e) {
62662       {
62663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62664       };
62665     } catch (std::exception& e) {
62666       {
62667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62668       };
62669     } catch (Dali::DaliException e) {
62670       {
62671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62672       };
62673     } catch (...) {
62674       {
62675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62676       };
62677     }
62678   }
62679
62680   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62681
62682   //argout typemap for const std::string&
62683
62684   return jresult;
62685 }
62686
62687
62688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62689   void * jresult ;
62690   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62691   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62692
62693   arg1 = (Dali::Toolkit::Builder *)jarg1;
62694   {
62695     try {
62696       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62697     } catch (std::out_of_range& e) {
62698       {
62699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62700       };
62701     } catch (std::exception& e) {
62702       {
62703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62704       };
62705     } catch (Dali::DaliException e) {
62706       {
62707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62708       };
62709     } catch (...) {
62710       {
62711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62712       };
62713     }
62714   }
62715
62716   jresult = (void *)result;
62717   return jresult;
62718 }
62719
62720
62721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62722   void * jresult ;
62723   Dali::Toolkit::TransitionData *result = 0 ;
62724
62725   {
62726     try {
62727       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62728     } catch (std::out_of_range& e) {
62729       {
62730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62731       };
62732     } catch (std::exception& e) {
62733       {
62734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62735       };
62736     } catch (Dali::DaliException e) {
62737       {
62738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62739       };
62740     } catch (...) {
62741       {
62742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62743       };
62744     }
62745   }
62746
62747   jresult = (void *)result;
62748   return jresult;
62749 }
62750
62751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62752   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62753
62754   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62755   {
62756     try {
62757       delete arg1;
62758     } catch (std::out_of_range& e) {
62759       {
62760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62761       };
62762     } catch (std::exception& e) {
62763       {
62764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62765       };
62766     } catch (Dali::DaliException e) {
62767       {
62768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62769       };
62770     } catch (...) {
62771       {
62772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62773       };
62774     }
62775   }
62776
62777 }
62778
62779
62780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62781   void * jresult ;
62782   Dali::Property::Map *arg1 = 0 ;
62783   Dali::Toolkit::TransitionData result;
62784
62785   arg1 = (Dali::Property::Map *)jarg1;
62786   if (!arg1) {
62787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62788     return 0;
62789   }
62790   {
62791     try {
62792       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62793     } catch (std::out_of_range& e) {
62794       {
62795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62796       };
62797     } catch (std::exception& e) {
62798       {
62799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62800       };
62801     } catch (Dali::DaliException e) {
62802       {
62803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62804       };
62805     } catch (...) {
62806       {
62807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62808       };
62809     }
62810   }
62811
62812   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62813   return jresult;
62814 }
62815
62816
62817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62818   void * jresult ;
62819   Dali::Property::Array *arg1 = 0 ;
62820   Dali::Toolkit::TransitionData result;
62821
62822   arg1 = (Dali::Property::Array *)jarg1;
62823   if (!arg1) {
62824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62825     return 0;
62826   }
62827   {
62828     try {
62829       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62830     } catch (std::out_of_range& e) {
62831       {
62832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62833       };
62834     } catch (std::exception& e) {
62835       {
62836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62837       };
62838     } catch (Dali::DaliException e) {
62839       {
62840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62841       };
62842     } catch (...) {
62843       {
62844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62845       };
62846     }
62847   }
62848
62849   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62850   return jresult;
62851 }
62852
62853
62854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62855   void * jresult ;
62856   Dali::BaseHandle arg1 ;
62857   Dali::BaseHandle *argp1 ;
62858   Dali::Toolkit::TransitionData result;
62859
62860   argp1 = (Dali::BaseHandle *)jarg1;
62861   if (!argp1) {
62862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62863     return 0;
62864   }
62865   arg1 = *argp1;
62866   {
62867     try {
62868       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62869     } catch (std::out_of_range& e) {
62870       {
62871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62872       };
62873     } catch (std::exception& e) {
62874       {
62875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62876       };
62877     } catch (Dali::DaliException e) {
62878       {
62879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62880       };
62881     } catch (...) {
62882       {
62883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62884       };
62885     }
62886   }
62887
62888   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62889   return jresult;
62890 }
62891
62892
62893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62894   void * jresult ;
62895   Dali::Toolkit::TransitionData *arg1 = 0 ;
62896   Dali::Toolkit::TransitionData *result = 0 ;
62897
62898   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62899   if (!arg1) {
62900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62901     return 0;
62902   }
62903   {
62904     try {
62905       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62906     } catch (std::out_of_range& e) {
62907       {
62908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62909       };
62910     } catch (std::exception& e) {
62911       {
62912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62913       };
62914     } catch (Dali::DaliException e) {
62915       {
62916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62917       };
62918     } catch (...) {
62919       {
62920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62921       };
62922     }
62923   }
62924
62925   jresult = (void *)result;
62926   return jresult;
62927 }
62928
62929
62930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62931   void * jresult ;
62932   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62933   Dali::Toolkit::TransitionData *arg2 = 0 ;
62934   Dali::Toolkit::TransitionData *result = 0 ;
62935
62936   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62937   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62938   if (!arg2) {
62939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62940     return 0;
62941   }
62942   {
62943     try {
62944       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62945     } catch (std::out_of_range& e) {
62946       {
62947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62948       };
62949     } catch (std::exception& e) {
62950       {
62951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62952       };
62953     } catch (Dali::DaliException e) {
62954       {
62955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62956       };
62957     } catch (...) {
62958       {
62959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62960       };
62961     }
62962   }
62963
62964   jresult = (void *)result;
62965   return jresult;
62966 }
62967
62968
62969 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62970   unsigned long jresult ;
62971   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62972   size_t result;
62973
62974   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62975   {
62976     try {
62977       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62978     } catch (std::out_of_range& e) {
62979       {
62980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62981       };
62982     } catch (std::exception& e) {
62983       {
62984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62985       };
62986     } catch (Dali::DaliException e) {
62987       {
62988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62989       };
62990     } catch (...) {
62991       {
62992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62993       };
62994     }
62995   }
62996
62997   jresult = (unsigned long)result;
62998   return jresult;
62999 }
63000
63001
63002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
63003   void * jresult ;
63004   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
63005   size_t arg2 ;
63006   Dali::Property::Map result;
63007
63008   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
63009   arg2 = (size_t)jarg2;
63010   {
63011     try {
63012       result = (arg1)->GetAnimatorAt(arg2);
63013     } catch (std::out_of_range& e) {
63014       {
63015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63016       };
63017     } catch (std::exception& e) {
63018       {
63019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63020       };
63021     } catch (Dali::DaliException e) {
63022       {
63023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63024       };
63025     } catch (...) {
63026       {
63027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63028       };
63029     }
63030   }
63031
63032   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
63033   return jresult;
63034 }
63035
63036
63037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
63038   int jresult ;
63039   int result;
63040
63041   {
63042     try {
63043       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63044     } catch (std::out_of_range& e) {
63045       {
63046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63047       };
63048     } catch (std::exception& e) {
63049       {
63050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63051       };
63052     } catch (Dali::DaliException e) {
63053       {
63054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63055       };
63056     } catch (...) {
63057       {
63058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63059       };
63060     }
63061   }
63062
63063   jresult = (int)result;
63064   return jresult;
63065 }
63066
63067
63068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63069   int jresult ;
63070   int result;
63071
63072   {
63073     try {
63074       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63075     } catch (std::out_of_range& e) {
63076       {
63077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63078       };
63079     } catch (std::exception& e) {
63080       {
63081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63082       };
63083     } catch (Dali::DaliException e) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63086       };
63087     } catch (...) {
63088       {
63089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63090       };
63091     }
63092   }
63093
63094   jresult = (int)result;
63095   return jresult;
63096 }
63097
63098
63099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63100   int jresult ;
63101   int result;
63102
63103   {
63104     try {
63105       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63106     } catch (std::out_of_range& e) {
63107       {
63108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63109       };
63110     } catch (std::exception& e) {
63111       {
63112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63113       };
63114     } catch (Dali::DaliException e) {
63115       {
63116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63117       };
63118     } catch (...) {
63119       {
63120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63121       };
63122     }
63123   }
63124
63125   jresult = (int)result;
63126   return jresult;
63127 }
63128
63129
63130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63131   int jresult ;
63132   int result;
63133
63134   {
63135     try {
63136       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63137     } catch (std::out_of_range& e) {
63138       {
63139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63140       };
63141     } catch (std::exception& e) {
63142       {
63143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63144       };
63145     } catch (Dali::DaliException e) {
63146       {
63147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63148       };
63149     } catch (...) {
63150       {
63151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63152       };
63153     }
63154   }
63155
63156   jresult = (int)result;
63157   return jresult;
63158 }
63159
63160
63161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63162   int jresult ;
63163   int result;
63164
63165   {
63166     try {
63167       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63168     } catch (std::out_of_range& e) {
63169       {
63170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63171       };
63172     } catch (std::exception& e) {
63173       {
63174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63175       };
63176     } catch (Dali::DaliException e) {
63177       {
63178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63179       };
63180     } catch (...) {
63181       {
63182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63183       };
63184     }
63185   }
63186
63187   jresult = (int)result;
63188   return jresult;
63189 }
63190
63191
63192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63193   int jresult ;
63194   int result;
63195
63196   {
63197     try {
63198       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63199     } catch (std::out_of_range& e) {
63200       {
63201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63202       };
63203     } catch (std::exception& e) {
63204       {
63205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63206       };
63207     } catch (Dali::DaliException e) {
63208       {
63209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63210       };
63211     } catch (...) {
63212       {
63213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63214       };
63215     }
63216   }
63217
63218   jresult = (int)result;
63219   return jresult;
63220 }
63221
63222
63223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63224   int jresult ;
63225   int result;
63226
63227   {
63228     try {
63229       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63230     } catch (std::out_of_range& e) {
63231       {
63232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63233       };
63234     } catch (std::exception& e) {
63235       {
63236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63237       };
63238     } catch (Dali::DaliException e) {
63239       {
63240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63241       };
63242     } catch (...) {
63243       {
63244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63245       };
63246     }
63247   }
63248
63249   jresult = (int)result;
63250   return jresult;
63251 }
63252
63253
63254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63255   int jresult ;
63256   int result;
63257
63258   {
63259     try {
63260       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63261     } catch (std::out_of_range& e) {
63262       {
63263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63264       };
63265     } catch (std::exception& e) {
63266       {
63267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63268       };
63269     } catch (Dali::DaliException e) {
63270       {
63271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63272       };
63273     } catch (...) {
63274       {
63275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63276       };
63277     }
63278   }
63279
63280   jresult = (int)result;
63281   return jresult;
63282 }
63283
63284
63285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63286   int jresult ;
63287   int result;
63288
63289   {
63290     try {
63291       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63292     } catch (std::out_of_range& e) {
63293       {
63294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63295       };
63296     } catch (std::exception& e) {
63297       {
63298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63299       };
63300     } catch (Dali::DaliException e) {
63301       {
63302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63303       };
63304     } catch (...) {
63305       {
63306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63307       };
63308     }
63309   }
63310
63311   jresult = (int)result;
63312   return jresult;
63313 }
63314
63315
63316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63317   int jresult ;
63318   int result;
63319
63320   {
63321     try {
63322       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63323     } catch (std::out_of_range& e) {
63324       {
63325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63326       };
63327     } catch (std::exception& e) {
63328       {
63329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63330       };
63331     } catch (Dali::DaliException e) {
63332       {
63333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63334       };
63335     } catch (...) {
63336       {
63337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63338       };
63339     }
63340   }
63341
63342   jresult = (int)result;
63343   return jresult;
63344 }
63345
63346
63347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63348   int jresult ;
63349   int result;
63350
63351   {
63352     try {
63353       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63354     } catch (std::out_of_range& e) {
63355       {
63356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63357       };
63358     } catch (std::exception& e) {
63359       {
63360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63361       };
63362     } catch (Dali::DaliException e) {
63363       {
63364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63365       };
63366     } catch (...) {
63367       {
63368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63369       };
63370     }
63371   }
63372
63373   jresult = (int)result;
63374   return jresult;
63375 }
63376
63377
63378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63379   int jresult ;
63380   int result;
63381
63382   {
63383     try {
63384       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63385     } catch (std::out_of_range& e) {
63386       {
63387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63388       };
63389     } catch (std::exception& e) {
63390       {
63391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63392       };
63393     } catch (Dali::DaliException e) {
63394       {
63395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63396       };
63397     } catch (...) {
63398       {
63399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63400       };
63401     }
63402   }
63403
63404   jresult = (int)result;
63405   return jresult;
63406 }
63407
63408
63409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63410   int jresult ;
63411   int result;
63412
63413   {
63414     try {
63415       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63416     } catch (std::out_of_range& e) {
63417       {
63418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63419       };
63420     } catch (std::exception& e) {
63421       {
63422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63423       };
63424     } catch (Dali::DaliException e) {
63425       {
63426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63427       };
63428     } catch (...) {
63429       {
63430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63431       };
63432     }
63433   }
63434
63435   jresult = (int)result;
63436   return jresult;
63437 }
63438
63439
63440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63441   int jresult ;
63442   int result;
63443
63444   {
63445     try {
63446       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63447     } catch (std::out_of_range& e) {
63448       {
63449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63450       };
63451     } catch (std::exception& e) {
63452       {
63453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63454       };
63455     } catch (Dali::DaliException e) {
63456       {
63457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63458       };
63459     } catch (...) {
63460       {
63461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63462       };
63463     }
63464   }
63465
63466   jresult = (int)result;
63467   return jresult;
63468 }
63469
63470
63471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63472   void * jresult ;
63473   Dali::Toolkit::Control result;
63474
63475   {
63476     try {
63477       result = Dali::Toolkit::Internal::Control::New();
63478     } catch (std::out_of_range& e) {
63479       {
63480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63481       };
63482     } catch (std::exception& e) {
63483       {
63484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63485       };
63486     } catch (Dali::DaliException e) {
63487       {
63488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63489       };
63490     } catch (...) {
63491       {
63492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63493       };
63494     }
63495   }
63496
63497   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63498   return jresult;
63499 }
63500
63501
63502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63504   std::string *arg2 = 0 ;
63505
63506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63507   if (!jarg2) {
63508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63509     return ;
63510   }
63511   std::string arg2_str(jarg2);
63512   arg2 = &arg2_str;
63513   {
63514     try {
63515       (arg1)->SetStyleName((std::string const &)*arg2);
63516     } catch (std::out_of_range& e) {
63517       {
63518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63519       };
63520     } catch (std::exception& e) {
63521       {
63522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63523       };
63524     } catch (Dali::DaliException e) {
63525       {
63526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63527       };
63528     } catch (...) {
63529       {
63530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63531       };
63532     }
63533   }
63534
63535
63536   //argout typemap for const std::string&
63537
63538 }
63539
63540
63541 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63542   char * jresult ;
63543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63544   std::string *result = 0 ;
63545
63546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63547   {
63548     try {
63549       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63550     } catch (std::out_of_range& e) {
63551       {
63552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63553       };
63554     } catch (std::exception& e) {
63555       {
63556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63557       };
63558     } catch (Dali::DaliException e) {
63559       {
63560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63561       };
63562     } catch (...) {
63563       {
63564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63565       };
63566     }
63567   }
63568
63569   jresult = SWIG_csharp_string_callback(result->c_str());
63570   return jresult;
63571 }
63572
63573
63574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63576   Dali::Vector4 *arg2 = 0 ;
63577
63578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63579   arg2 = (Dali::Vector4 *)jarg2;
63580   if (!arg2) {
63581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63582     return ;
63583   }
63584   {
63585     try {
63586       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63587     } catch (std::out_of_range& e) {
63588       {
63589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63590       };
63591     } catch (std::exception& e) {
63592       {
63593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63594       };
63595     } catch (Dali::DaliException e) {
63596       {
63597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63598       };
63599     } catch (...) {
63600       {
63601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63602       };
63603     }
63604   }
63605
63606 }
63607
63608
63609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63610   void * jresult ;
63611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63612   Dali::Vector4 result;
63613
63614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63615   {
63616     try {
63617       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63618     } catch (std::out_of_range& e) {
63619       {
63620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63621       };
63622     } catch (std::exception& e) {
63623       {
63624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63625       };
63626     } catch (Dali::DaliException e) {
63627       {
63628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63629       };
63630     } catch (...) {
63631       {
63632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63633       };
63634     }
63635   }
63636
63637   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63638   return jresult;
63639 }
63640
63641
63642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63644   Dali::Image arg2 ;
63645   Dali::Image *argp2 ;
63646
63647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63648   argp2 = (Dali::Image *)jarg2;
63649   if (!argp2) {
63650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63651     return ;
63652   }
63653   arg2 = *argp2;
63654   {
63655     try {
63656       (arg1)->SetBackgroundImage(arg2);
63657     } catch (std::out_of_range& e) {
63658       {
63659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63660       };
63661     } catch (std::exception& e) {
63662       {
63663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63664       };
63665     } catch (Dali::DaliException e) {
63666       {
63667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63668       };
63669     } catch (...) {
63670       {
63671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63672       };
63673     }
63674   }
63675
63676 }
63677
63678
63679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63681   Dali::Property::Map *arg2 = 0 ;
63682
63683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63684   arg2 = (Dali::Property::Map *)jarg2;
63685   if (!arg2) {
63686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63687     return ;
63688   }
63689   {
63690     try {
63691       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63692     } catch (std::out_of_range& e) {
63693       {
63694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63695       };
63696     } catch (std::exception& e) {
63697       {
63698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63699       };
63700     } catch (Dali::DaliException e) {
63701       {
63702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63703       };
63704     } catch (...) {
63705       {
63706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63707       };
63708     }
63709   }
63710
63711 }
63712
63713
63714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63716
63717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63718   {
63719     try {
63720       (arg1)->ClearBackground();
63721     } catch (std::out_of_range& e) {
63722       {
63723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63724       };
63725     } catch (std::exception& e) {
63726       {
63727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63728       };
63729     } catch (Dali::DaliException e) {
63730       {
63731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63732       };
63733     } catch (...) {
63734       {
63735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63736       };
63737     }
63738   }
63739
63740 }
63741
63742
63743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63745   Dali::Gesture::Type arg2 ;
63746
63747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63748   arg2 = (Dali::Gesture::Type)jarg2;
63749   {
63750     try {
63751       (arg1)->EnableGestureDetection(arg2);
63752     } catch (std::out_of_range& e) {
63753       {
63754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63755       };
63756     } catch (std::exception& e) {
63757       {
63758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63759       };
63760     } catch (Dali::DaliException e) {
63761       {
63762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63763       };
63764     } catch (...) {
63765       {
63766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63767       };
63768     }
63769   }
63770
63771 }
63772
63773
63774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63776   Dali::Gesture::Type arg2 ;
63777
63778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63779   arg2 = (Dali::Gesture::Type)jarg2;
63780   {
63781     try {
63782       (arg1)->DisableGestureDetection(arg2);
63783     } catch (std::out_of_range& e) {
63784       {
63785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63786       };
63787     } catch (std::exception& e) {
63788       {
63789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63790       };
63791     } catch (Dali::DaliException e) {
63792       {
63793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63794       };
63795     } catch (...) {
63796       {
63797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63798       };
63799     }
63800   }
63801
63802 }
63803
63804
63805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63806   void * jresult ;
63807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63808   Dali::PinchGestureDetector result;
63809
63810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63811   {
63812     try {
63813       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63814     } catch (std::out_of_range& e) {
63815       {
63816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63817       };
63818     } catch (std::exception& e) {
63819       {
63820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63821       };
63822     } catch (Dali::DaliException e) {
63823       {
63824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63825       };
63826     } catch (...) {
63827       {
63828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63829       };
63830     }
63831   }
63832
63833   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63834   return jresult;
63835 }
63836
63837
63838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63839   void * jresult ;
63840   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63841   Dali::PanGestureDetector result;
63842
63843   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63844   {
63845     try {
63846       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63847     } catch (std::out_of_range& e) {
63848       {
63849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63850       };
63851     } catch (std::exception& e) {
63852       {
63853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63854       };
63855     } catch (Dali::DaliException e) {
63856       {
63857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63858       };
63859     } catch (...) {
63860       {
63861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63862       };
63863     }
63864   }
63865
63866   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63867   return jresult;
63868 }
63869
63870
63871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63872   void * jresult ;
63873   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63874   Dali::TapGestureDetector result;
63875
63876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63877   {
63878     try {
63879       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63880     } catch (std::out_of_range& e) {
63881       {
63882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63883       };
63884     } catch (std::exception& e) {
63885       {
63886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63887       };
63888     } catch (Dali::DaliException e) {
63889       {
63890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63891       };
63892     } catch (...) {
63893       {
63894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63895       };
63896     }
63897   }
63898
63899   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63900   return jresult;
63901 }
63902
63903
63904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63905   void * jresult ;
63906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63907   Dali::LongPressGestureDetector result;
63908
63909   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63910   {
63911     try {
63912       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63913     } catch (std::out_of_range& e) {
63914       {
63915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63916       };
63917     } catch (std::exception& e) {
63918       {
63919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63920       };
63921     } catch (Dali::DaliException e) {
63922       {
63923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63924       };
63925     } catch (...) {
63926       {
63927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63928       };
63929     }
63930   }
63931
63932   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63933   return jresult;
63934 }
63935
63936
63937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63939   bool arg2 ;
63940
63941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63942   arg2 = jarg2 ? true : false;
63943   {
63944     try {
63945       (arg1)->SetKeyboardNavigationSupport(arg2);
63946     } catch (std::out_of_range& e) {
63947       {
63948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63949       };
63950     } catch (std::exception& e) {
63951       {
63952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63953       };
63954     } catch (Dali::DaliException e) {
63955       {
63956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63957       };
63958     } catch (...) {
63959       {
63960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63961       };
63962     }
63963   }
63964
63965 }
63966
63967
63968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63969   unsigned int jresult ;
63970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63971   bool result;
63972
63973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63974   {
63975     try {
63976       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63977     } catch (std::out_of_range& e) {
63978       {
63979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63980       };
63981     } catch (std::exception& e) {
63982       {
63983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63984       };
63985     } catch (Dali::DaliException e) {
63986       {
63987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63988       };
63989     } catch (...) {
63990       {
63991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63992       };
63993     }
63994   }
63995
63996   jresult = result;
63997   return jresult;
63998 }
63999
64000
64001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
64002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64003
64004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64005   {
64006     try {
64007       (arg1)->SetKeyInputFocus();
64008     } catch (std::out_of_range& e) {
64009       {
64010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64011       };
64012     } catch (std::exception& e) {
64013       {
64014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64015       };
64016     } catch (Dali::DaliException e) {
64017       {
64018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64019       };
64020     } catch (...) {
64021       {
64022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64023       };
64024     }
64025   }
64026
64027 }
64028
64029
64030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
64031   unsigned int jresult ;
64032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64033   bool result;
64034
64035   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64036   {
64037     try {
64038       result = (bool)(arg1)->HasKeyInputFocus();
64039     } catch (std::out_of_range& e) {
64040       {
64041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64042       };
64043     } catch (std::exception& e) {
64044       {
64045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64046       };
64047     } catch (Dali::DaliException e) {
64048       {
64049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64050       };
64051     } catch (...) {
64052       {
64053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64054       };
64055     }
64056   }
64057
64058   jresult = result;
64059   return jresult;
64060 }
64061
64062
64063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64064   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64065
64066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64067   {
64068     try {
64069       (arg1)->ClearKeyInputFocus();
64070     } catch (std::out_of_range& e) {
64071       {
64072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64073       };
64074     } catch (std::exception& e) {
64075       {
64076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64077       };
64078     } catch (Dali::DaliException e) {
64079       {
64080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64081       };
64082     } catch (...) {
64083       {
64084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64085       };
64086     }
64087   }
64088
64089 }
64090
64091
64092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64093   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64094   bool arg2 ;
64095
64096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64097   arg2 = jarg2 ? true : false;
64098   {
64099     try {
64100       (arg1)->SetAsKeyboardFocusGroup(arg2);
64101     } catch (std::out_of_range& e) {
64102       {
64103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64104       };
64105     } catch (std::exception& e) {
64106       {
64107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64108       };
64109     } catch (Dali::DaliException e) {
64110       {
64111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64112       };
64113     } catch (...) {
64114       {
64115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64116       };
64117     }
64118   }
64119
64120 }
64121
64122
64123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64124   unsigned int jresult ;
64125   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64126   bool result;
64127
64128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64129   {
64130     try {
64131       result = (bool)(arg1)->IsKeyboardFocusGroup();
64132     } catch (std::out_of_range& e) {
64133       {
64134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64135       };
64136     } catch (std::exception& e) {
64137       {
64138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64139       };
64140     } catch (Dali::DaliException e) {
64141       {
64142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64143       };
64144     } catch (...) {
64145       {
64146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64147       };
64148     }
64149   }
64150
64151   jresult = result;
64152   return jresult;
64153 }
64154
64155
64156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64157   void * jresult ;
64158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64159   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64160
64161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64162   {
64163     try {
64164       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64165     } catch (std::out_of_range& e) {
64166       {
64167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64168       };
64169     } catch (std::exception& e) {
64170       {
64171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64172       };
64173     } catch (Dali::DaliException e) {
64174       {
64175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64176       };
64177     } catch (...) {
64178       {
64179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64180       };
64181     }
64182   }
64183
64184   jresult = (void *)result;
64185   return jresult;
64186 }
64187
64188
64189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64190   void * jresult ;
64191   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64192   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64193
64194   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64195   {
64196     try {
64197       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64198     } catch (std::out_of_range& e) {
64199       {
64200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64201       };
64202     } catch (std::exception& e) {
64203       {
64204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64205       };
64206     } catch (Dali::DaliException e) {
64207       {
64208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64209       };
64210     } catch (...) {
64211       {
64212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64213       };
64214     }
64215   }
64216
64217   jresult = (void *)result;
64218   return jresult;
64219 }
64220
64221
64222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64223   void * jresult ;
64224   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64225   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64226
64227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64228   {
64229     try {
64230       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64231     } catch (std::out_of_range& e) {
64232       {
64233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64234       };
64235     } catch (std::exception& e) {
64236       {
64237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64238       };
64239     } catch (Dali::DaliException e) {
64240       {
64241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64242       };
64243     } catch (...) {
64244       {
64245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64246       };
64247     }
64248   }
64249
64250   jresult = (void *)result;
64251   return jresult;
64252 }
64253
64254
64255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64257   int arg2 ;
64258   SwigDirector_ViewImpl *darg = 0;
64259
64260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64261   arg2 = (int)jarg2;
64262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64263   if(!darg) {
64264     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64265     return;
64266   }
64267   {
64268     try {
64269       if(darg) {
64270         (darg)->OnStageConnection(arg2);
64271       }
64272     } catch (std::out_of_range& e) {
64273       {
64274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64275       };
64276     } catch (std::exception& e) {
64277       {
64278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64279       };
64280     } catch (Dali::DaliException e) {
64281       {
64282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64283       };
64284     } catch (...) {
64285       {
64286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64287       };
64288     }
64289   }
64290
64291 }
64292
64293
64294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64295   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64296   int arg2 ;
64297   SwigDirector_ViewImpl *darg = 0;
64298
64299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64300   arg2 = (int)jarg2;
64301   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64302   if(!darg) {
64303     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64304     return;
64305   }
64306   {
64307     try {
64308       if(darg) {
64309         (darg)->OnStageConnectionSwigPublic(arg2);
64310       }
64311     } catch (std::out_of_range& e) {
64312       {
64313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64314       };
64315     } catch (std::exception& e) {
64316       {
64317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64318       };
64319     } catch (Dali::DaliException e) {
64320       {
64321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64322       };
64323     } catch (...) {
64324       {
64325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64326       };
64327     }
64328   }
64329
64330 }
64331
64332
64333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64334   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64335   SwigDirector_ViewImpl *darg = 0;
64336
64337   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64338   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64339   if(!darg) {
64340     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64341     return;
64342   }
64343   {
64344     try {
64345       if(darg) {
64346         (darg)->OnStageDisconnection();
64347       }
64348     } catch (std::out_of_range& e) {
64349       {
64350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64351       };
64352     } catch (std::exception& e) {
64353       {
64354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64355       };
64356     } catch (Dali::DaliException e) {
64357       {
64358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64359       };
64360     } catch (...) {
64361       {
64362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64363       };
64364     }
64365   }
64366
64367 }
64368
64369
64370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64372   SwigDirector_ViewImpl *darg = 0;
64373
64374   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64375   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64376   if(!darg) {
64377     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64378     return;
64379   }
64380   {
64381     try {
64382       if(darg) {
64383         (darg)->OnStageDisconnectionSwigPublic();
64384       }
64385     } catch (std::out_of_range& e) {
64386       {
64387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64388       };
64389     } catch (std::exception& e) {
64390       {
64391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64392       };
64393     } catch (Dali::DaliException e) {
64394       {
64395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64396       };
64397     } catch (...) {
64398       {
64399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64400       };
64401     }
64402   }
64403
64404 }
64405
64406
64407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64408   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64409   Dali::Actor *arg2 = 0 ;
64410   SwigDirector_ViewImpl *darg = 0;
64411
64412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64413   arg2 = (Dali::Actor *)jarg2;
64414   if (!arg2) {
64415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64416     return ;
64417   }
64418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64419   if(!darg) {
64420     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64421     return;
64422   }
64423   {
64424     try {
64425       if(darg) {
64426         (darg)->OnChildAdd(*arg2);
64427       }
64428     } catch (std::out_of_range& e) {
64429       {
64430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64431       };
64432     } catch (std::exception& e) {
64433       {
64434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64435       };
64436     } catch (Dali::DaliException e) {
64437       {
64438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64439       };
64440     } catch (...) {
64441       {
64442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64443       };
64444     }
64445   }
64446
64447 }
64448
64449
64450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64452   Dali::Actor *arg2 = 0 ;
64453   SwigDirector_ViewImpl *darg = 0;
64454
64455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64456   arg2 = (Dali::Actor *)jarg2;
64457   if (!arg2) {
64458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64459     return ;
64460   }
64461   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64462   if(!darg) {
64463     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64464     return;
64465   }
64466   {
64467     try {
64468       if(darg) {
64469           (darg)->OnChildAddSwigPublic(*arg2);
64470       }
64471     } catch (std::out_of_range& e) {
64472       {
64473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64474       };
64475     } catch (std::exception& e) {
64476       {
64477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64478       };
64479     } catch (Dali::DaliException e) {
64480       {
64481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64482       };
64483     } catch (...) {
64484       {
64485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64486       };
64487     }
64488   }
64489
64490 }
64491
64492
64493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64495   Dali::Actor *arg2 = 0 ;
64496   SwigDirector_ViewImpl *darg = 0;
64497
64498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64499   arg2 = (Dali::Actor *)jarg2;
64500   if (!arg2) {
64501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64502     return ;
64503   }
64504   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64505   if(!darg) {
64506     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64507     return;
64508   }
64509   {
64510     try {
64511       if(darg) {
64512         (darg)->OnChildRemove(*arg2);
64513       }
64514     } catch (std::out_of_range& e) {
64515       {
64516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64517       };
64518     } catch (std::exception& e) {
64519       {
64520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64521       };
64522     } catch (Dali::DaliException e) {
64523       {
64524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64525       };
64526     } catch (...) {
64527       {
64528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64529       };
64530     }
64531   }
64532
64533 }
64534
64535
64536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64538   Dali::Actor *arg2 = 0 ;
64539   SwigDirector_ViewImpl *darg = 0;
64540
64541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64542   arg2 = (Dali::Actor *)jarg2;
64543   if (!arg2) {
64544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64545     return ;
64546   }
64547   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64548   if(!darg) {
64549     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64550     return;
64551   }
64552   {
64553     try {
64554       if(darg) {
64555         (darg)->OnChildRemoveSwigPublic(*arg2);
64556       }
64557     } catch (std::out_of_range& e) {
64558       {
64559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64560       };
64561     } catch (std::exception& e) {
64562       {
64563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64564       };
64565     } catch (Dali::DaliException e) {
64566       {
64567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64568       };
64569     } catch (...) {
64570       {
64571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64572       };
64573     }
64574   }
64575
64576 }
64577
64578
64579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64580   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64581   Dali::Property::Index arg2 ;
64582   Dali::Property::Value arg3 ;
64583   Dali::Property::Value *argp3 ;
64584   SwigDirector_ViewImpl *darg = 0;
64585
64586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64587   arg2 = (Dali::Property::Index)jarg2;
64588   argp3 = (Dali::Property::Value *)jarg3;
64589   if (!argp3) {
64590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64591     return ;
64592   }
64593   arg3 = *argp3;
64594   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64595   if (!darg) {
64596     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64597     return;
64598   }
64599   {
64600     try {
64601       (darg)->OnPropertySet(arg2,arg3);
64602     } catch (std::out_of_range& e) {
64603       {
64604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64605       };
64606     } catch (std::exception& e) {
64607       {
64608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64609       };
64610     } catch (Dali::DaliException e) {
64611       {
64612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64613       };
64614     } catch (...) {
64615       {
64616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64617       };
64618     }
64619   }
64620
64621 }
64622
64623
64624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64626   Dali::Property::Index arg2 ;
64627   Dali::Property::Value arg3 ;
64628   Dali::Property::Value *argp3 ;
64629   SwigDirector_ViewImpl *darg = 0;
64630
64631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64632   arg2 = (Dali::Property::Index)jarg2;
64633   argp3 = (Dali::Property::Value *)jarg3;
64634   if (!argp3) {
64635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64636     return ;
64637   }
64638   arg3 = *argp3;
64639   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64640   if (!darg) {
64641     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64642     return;
64643   }
64644   {
64645     try {
64646       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64647     } catch (std::out_of_range& e) {
64648       {
64649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64650       };
64651     } catch (std::exception& e) {
64652       {
64653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64654       };
64655     } catch (Dali::DaliException e) {
64656       {
64657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64658       };
64659     } catch (...) {
64660       {
64661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64662       };
64663     }
64664   }
64665
64666 }
64667
64668
64669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64671   Dali::Vector3 *arg2 = 0 ;
64672   SwigDirector_ViewImpl *darg = 0;
64673
64674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64675   arg2 = (Dali::Vector3 *)jarg2;
64676   if (!arg2) {
64677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64678     return ;
64679   }
64680   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64681   if (!darg) {
64682     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64683     return;
64684   }
64685   {
64686     try {
64687       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64688     } catch (std::out_of_range& e) {
64689       {
64690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64691       };
64692     } catch (std::exception& e) {
64693       {
64694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64695       };
64696     } catch (Dali::DaliException e) {
64697       {
64698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64699       };
64700     } catch (...) {
64701       {
64702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64703       };
64704     }
64705   }
64706
64707 }
64708
64709
64710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64712   Dali::Vector3 *arg2 = 0 ;
64713   SwigDirector_ViewImpl *darg = 0;
64714
64715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64716   arg2 = (Dali::Vector3 *)jarg2;
64717   if (!arg2) {
64718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64719     return ;
64720   }
64721   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64722   if (!darg) {
64723     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64724     return;
64725   }
64726   {
64727     try {
64728       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64729     } catch (std::out_of_range& e) {
64730       {
64731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64732       };
64733     } catch (std::exception& e) {
64734       {
64735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64736       };
64737     } catch (Dali::DaliException e) {
64738       {
64739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64740       };
64741     } catch (...) {
64742       {
64743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64744       };
64745     }
64746   }
64747
64748 }
64749
64750
64751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64753   Dali::Animation *arg2 = 0 ;
64754   Dali::Vector3 *arg3 = 0 ;
64755   SwigDirector_ViewImpl *darg = 0;
64756
64757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64758   arg2 = (Dali::Animation *)jarg2;
64759   if (!arg2) {
64760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64761     return ;
64762   }
64763   arg3 = (Dali::Vector3 *)jarg3;
64764   if (!arg3) {
64765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64766     return ;
64767   }
64768   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64769   if (!darg) {
64770     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64771     return;
64772   }
64773   {
64774     try {
64775       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64776     } catch (std::out_of_range& e) {
64777       {
64778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64779       };
64780     } catch (std::exception& e) {
64781       {
64782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64783       };
64784     } catch (Dali::DaliException e) {
64785       {
64786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64787       };
64788     } catch (...) {
64789       {
64790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64791       };
64792     }
64793   }
64794
64795 }
64796
64797
64798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64800   Dali::Animation *arg2 = 0 ;
64801   Dali::Vector3 *arg3 = 0 ;
64802   SwigDirector_ViewImpl *darg = 0;
64803
64804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64805   arg2 = (Dali::Animation *)jarg2;
64806   if (!arg2) {
64807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64808     return ;
64809   }
64810   arg3 = (Dali::Vector3 *)jarg3;
64811   if (!arg3) {
64812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64813     return ;
64814   }
64815   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64816   if (!darg) {
64817     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64818     return;
64819   }
64820   {
64821     try {
64822       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64823     } catch (std::out_of_range& e) {
64824       {
64825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64826       };
64827     } catch (std::exception& e) {
64828       {
64829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64830       };
64831     } catch (Dali::DaliException e) {
64832       {
64833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64834       };
64835     } catch (...) {
64836       {
64837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64838       };
64839     }
64840   }
64841
64842 }
64843
64844
64845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64846   unsigned int jresult ;
64847   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64848   Dali::TouchEvent *arg2 = 0 ;
64849   SwigDirector_ViewImpl *darg = 0;
64850   bool result;
64851
64852   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64853   arg2 = (Dali::TouchEvent *)jarg2;
64854   if (!arg2) {
64855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64856     return 0;
64857   }
64858   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64859   if (!darg) {
64860     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64861     return 0;
64862   }
64863   {
64864     try {
64865       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64866     } catch (std::out_of_range& e) {
64867       {
64868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64869       };
64870     } catch (std::exception& e) {
64871       {
64872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64873       };
64874     } catch (Dali::DaliException e) {
64875       {
64876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64877       };
64878     } catch (...) {
64879       {
64880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64881       };
64882     }
64883   }
64884
64885   jresult = result;
64886   return jresult;
64887 }
64888
64889
64890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64891   unsigned int jresult ;
64892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64893   Dali::TouchEvent *arg2 = 0 ;
64894   SwigDirector_ViewImpl *darg = 0;
64895   bool result;
64896
64897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64898   arg2 = (Dali::TouchEvent *)jarg2;
64899   if (!arg2) {
64900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64901     return 0;
64902   }
64903   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64904   if (!darg) {
64905     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64906     return 0;
64907   }
64908   {
64909     try {
64910       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64911     } catch (std::out_of_range& e) {
64912       {
64913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64914       };
64915     } catch (std::exception& e) {
64916       {
64917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64918       };
64919     } catch (Dali::DaliException e) {
64920       {
64921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64922       };
64923     } catch (...) {
64924       {
64925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64926       };
64927     }
64928   }
64929
64930   jresult = result;
64931   return jresult;
64932 }
64933
64934
64935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64936   unsigned int jresult ;
64937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64938   Dali::HoverEvent *arg2 = 0 ;
64939   SwigDirector_ViewImpl *darg = 0;
64940   bool result;
64941
64942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64943   arg2 = (Dali::HoverEvent *)jarg2;
64944   if (!arg2) {
64945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64946     return 0;
64947   }
64948   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64949   if (!darg) {
64950     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64951     return 0;
64952   }
64953   {
64954     try {
64955       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64956     } catch (std::out_of_range& e) {
64957       {
64958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64959       };
64960     } catch (std::exception& e) {
64961       {
64962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64963       };
64964     } catch (Dali::DaliException e) {
64965       {
64966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64967       };
64968     } catch (...) {
64969       {
64970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64971       };
64972     }
64973   }
64974
64975   jresult = result;
64976   return jresult;
64977 }
64978
64979
64980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64981   unsigned int jresult ;
64982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64983   Dali::HoverEvent *arg2 = 0 ;
64984   SwigDirector_ViewImpl *darg = 0;
64985   bool result;
64986
64987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64988   arg2 = (Dali::HoverEvent *)jarg2;
64989   if (!arg2) {
64990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64991     return 0;
64992   }
64993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64994   if (!darg) {
64995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64996     return 0;
64997   }
64998   {
64999     try {
65000       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
65001     } catch (std::out_of_range& e) {
65002       {
65003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65004       };
65005     } catch (std::exception& e) {
65006       {
65007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65008       };
65009     } catch (Dali::DaliException e) {
65010       {
65011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65012       };
65013     } catch (...) {
65014       {
65015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65016       };
65017     }
65018   }
65019
65020   jresult = result;
65021   return jresult;
65022 }
65023
65024
65025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65026   unsigned int jresult ;
65027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65028   Dali::KeyEvent *arg2 = 0 ;
65029   SwigDirector_ViewImpl *darg = 0;
65030   bool result;
65031
65032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65033   arg2 = (Dali::KeyEvent *)jarg2;
65034   if (!arg2) {
65035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65036     return 0;
65037   }
65038   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65039   if (!darg) {
65040     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65041     return 0;
65042   }
65043   {
65044     try {
65045       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65046     } catch (std::out_of_range& e) {
65047       {
65048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65049       };
65050     } catch (std::exception& e) {
65051       {
65052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65053       };
65054     } catch (Dali::DaliException e) {
65055       {
65056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65057       };
65058     } catch (...) {
65059       {
65060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65061       };
65062     }
65063   }
65064
65065   jresult = result;
65066   return jresult;
65067 }
65068
65069
65070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65071   unsigned int jresult ;
65072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65073   Dali::KeyEvent *arg2 = 0 ;
65074   SwigDirector_ViewImpl *darg = 0;
65075   bool result;
65076
65077   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65078   arg2 = (Dali::KeyEvent *)jarg2;
65079   if (!arg2) {
65080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65081     return 0;
65082   }
65083   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65084   if (!darg) {
65085     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65086     return 0;
65087   }
65088   {
65089     try {
65090       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65091     } catch (std::out_of_range& e) {
65092       {
65093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65094       };
65095     } catch (std::exception& e) {
65096       {
65097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65098       };
65099     } catch (Dali::DaliException e) {
65100       {
65101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65102       };
65103     } catch (...) {
65104       {
65105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65106       };
65107     }
65108   }
65109
65110   jresult = result;
65111   return jresult;
65112 }
65113
65114
65115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65116   unsigned int jresult ;
65117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65118   Dali::WheelEvent *arg2 = 0 ;
65119   SwigDirector_ViewImpl *darg = 0;
65120   bool result;
65121
65122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65123   arg2 = (Dali::WheelEvent *)jarg2;
65124   if (!arg2) {
65125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65126     return 0;
65127   }
65128   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65129   if (!darg) {
65130     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65131     return 0;
65132   }
65133   {
65134     try {
65135       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65136     } catch (std::out_of_range& e) {
65137       {
65138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65139       };
65140     } catch (std::exception& e) {
65141       {
65142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65143       };
65144     } catch (Dali::DaliException e) {
65145       {
65146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65147       };
65148     } catch (...) {
65149       {
65150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65151       };
65152     }
65153   }
65154
65155   jresult = result;
65156   return jresult;
65157 }
65158
65159
65160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65161   unsigned int jresult ;
65162   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65163   Dali::WheelEvent *arg2 = 0 ;
65164   SwigDirector_ViewImpl *darg = 0;
65165   bool result;
65166
65167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65168   arg2 = (Dali::WheelEvent *)jarg2;
65169   if (!arg2) {
65170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65171     return 0;
65172   }
65173   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65174   if (!darg) {
65175     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65176     return 0;
65177   }
65178   {
65179     try {
65180       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65181     } catch (std::out_of_range& e) {
65182       {
65183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65184       };
65185     } catch (std::exception& e) {
65186       {
65187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65188       };
65189     } catch (Dali::DaliException e) {
65190       {
65191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65192       };
65193     } catch (...) {
65194       {
65195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65196       };
65197     }
65198   }
65199
65200   jresult = result;
65201   return jresult;
65202 }
65203
65204
65205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65207   Dali::Vector2 *arg2 = 0 ;
65208   Dali::RelayoutContainer *arg3 = 0 ;
65209   SwigDirector_ViewImpl *darg = 0;
65210
65211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65212   arg2 = (Dali::Vector2 *)jarg2;
65213   if (!arg2) {
65214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65215     return ;
65216   }
65217   arg3 = (Dali::RelayoutContainer *)jarg3;
65218   if (!arg3) {
65219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65220     return ;
65221   }
65222   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65223   if (!darg) {
65224     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65225     return;
65226   }
65227   {
65228     try {
65229       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65230     } catch (std::out_of_range& e) {
65231       {
65232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65233       };
65234     } catch (std::exception& e) {
65235       {
65236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65237       };
65238     } catch (Dali::DaliException e) {
65239       {
65240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65241       };
65242     } catch (...) {
65243       {
65244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65245       };
65246     }
65247   }
65248
65249 }
65250
65251
65252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65254   Dali::Vector2 *arg2 = 0 ;
65255   Dali::RelayoutContainer *arg3 = 0 ;
65256   SwigDirector_ViewImpl *darg = 0;
65257
65258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65259   arg2 = (Dali::Vector2 *)jarg2;
65260   if (!arg2) {
65261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65262     return ;
65263   }
65264   arg3 = (Dali::RelayoutContainer *)jarg3;
65265   if (!arg3) {
65266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65267     return ;
65268   }
65269   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65270   if (!darg) {
65271     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65272     return;
65273   }
65274   {
65275     try {
65276       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65277     } catch (std::out_of_range& e) {
65278       {
65279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65280       };
65281     } catch (std::exception& e) {
65282       {
65283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65284       };
65285     } catch (Dali::DaliException e) {
65286       {
65287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65288       };
65289     } catch (...) {
65290       {
65291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65292       };
65293     }
65294   }
65295
65296 }
65297
65298
65299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65300   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65301   Dali::ResizePolicy::Type arg2 ;
65302   Dali::Dimension::Type arg3 ;
65303   SwigDirector_ViewImpl *darg = 0;
65304
65305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65306   arg2 = (Dali::ResizePolicy::Type)jarg2;
65307   arg3 = (Dali::Dimension::Type)jarg3;
65308   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65309   if (!darg) {
65310     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65311     return;
65312   }
65313   {
65314     try {
65315       (darg)->OnSetResizePolicy(arg2,arg3);
65316     } catch (std::out_of_range& e) {
65317       {
65318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65319       };
65320     } catch (std::exception& e) {
65321       {
65322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65323       };
65324     } catch (Dali::DaliException e) {
65325       {
65326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65327       };
65328     } catch (...) {
65329       {
65330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65331       };
65332     }
65333   }
65334
65335 }
65336
65337
65338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65340   Dali::ResizePolicy::Type arg2 ;
65341   Dali::Dimension::Type arg3 ;
65342   SwigDirector_ViewImpl *darg = 0;
65343
65344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65345   arg2 = (Dali::ResizePolicy::Type)jarg2;
65346   arg3 = (Dali::Dimension::Type)jarg3;
65347   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65348   if (!darg) {
65349     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65350     return;
65351   }
65352   {
65353     try {
65354       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65355     } catch (std::out_of_range& e) {
65356       {
65357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65358       };
65359     } catch (std::exception& e) {
65360       {
65361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65362       };
65363     } catch (Dali::DaliException e) {
65364       {
65365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65366       };
65367     } catch (...) {
65368       {
65369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65370       };
65371     }
65372   }
65373
65374 }
65375
65376
65377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65378   void * jresult ;
65379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65380   SwigDirector_ViewImpl *darg = 0;
65381   Dali::Vector3 result;
65382
65383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65384   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65385   if (!darg) {
65386     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65387     return 0;
65388   }
65389   {
65390     try {
65391       result = (darg)->GetNaturalSize();
65392     } catch (std::out_of_range& e) {
65393       {
65394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65395       };
65396     } catch (std::exception& e) {
65397       {
65398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65399       };
65400     } catch (Dali::DaliException e) {
65401       {
65402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65403       };
65404     } catch (...) {
65405       {
65406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65407       };
65408     }
65409   }
65410
65411   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65412   return jresult;
65413 }
65414
65415
65416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65417   void * jresult ;
65418   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65419   SwigDirector_ViewImpl *darg = 0;
65420   Dali::Vector3 result;
65421
65422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65423   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65424   if (!darg) {
65425     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65426     return 0;
65427   }
65428   {
65429     try {
65430       result = (darg)->GetNaturalSizeSwigPublic();
65431     } catch (std::out_of_range& e) {
65432       {
65433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65434       };
65435     } catch (std::exception& e) {
65436       {
65437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65438       };
65439     } catch (Dali::DaliException e) {
65440       {
65441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65442       };
65443     } catch (...) {
65444       {
65445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65446       };
65447     }
65448   }
65449
65450   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65451   return jresult;
65452 }
65453
65454
65455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65456   float jresult ;
65457   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65458   Dali::Actor *arg2 = 0 ;
65459   Dali::Dimension::Type arg3 ;
65460   SwigDirector_ViewImpl *darg = 0;
65461   float result;
65462
65463   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65464   arg2 = (Dali::Actor *)jarg2;
65465   if (!arg2) {
65466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65467     return 0;
65468   }
65469   arg3 = (Dali::Dimension::Type)jarg3;
65470   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65471   if (!darg) {
65472     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65473     return 0;
65474   }
65475   {
65476     try {
65477       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65478     } catch (std::out_of_range& e) {
65479       {
65480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65481       };
65482     } catch (std::exception& e) {
65483       {
65484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65485       };
65486     } catch (Dali::DaliException e) {
65487       {
65488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65489       };
65490     } catch (...) {
65491       {
65492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65493       };
65494     }
65495   }
65496
65497   jresult = result;
65498   return jresult;
65499 }
65500
65501
65502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65503   float jresult ;
65504   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65505   Dali::Actor *arg2 = 0 ;
65506   Dali::Dimension::Type arg3 ;
65507   SwigDirector_ViewImpl *darg = 0;
65508   float result;
65509
65510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65511   arg2 = (Dali::Actor *)jarg2;
65512   if (!arg2) {
65513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65514     return 0;
65515   }
65516   arg3 = (Dali::Dimension::Type)jarg3;
65517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65518   if (!darg) {
65519     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65520     return 0;
65521   }
65522   {
65523     try {
65524       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65525     } catch (std::out_of_range& e) {
65526       {
65527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65528       };
65529     } catch (std::exception& e) {
65530       {
65531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65532       };
65533     } catch (Dali::DaliException e) {
65534       {
65535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65536       };
65537     } catch (...) {
65538       {
65539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65540       };
65541     }
65542   }
65543
65544   jresult = result;
65545   return jresult;
65546 }
65547
65548
65549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65550   float jresult ;
65551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65552   float arg2 ;
65553   SwigDirector_ViewImpl *darg = 0;
65554   float result;
65555
65556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65557   arg2 = (float)jarg2;
65558   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65559   if (!darg) {
65560     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65561     return 0;
65562   }
65563   {
65564     try {
65565       result = (float)(darg)->GetHeightForWidth(arg2);
65566     } catch (std::out_of_range& e) {
65567       {
65568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65569       };
65570     } catch (std::exception& e) {
65571       {
65572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65573       };
65574     } catch (Dali::DaliException e) {
65575       {
65576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65577       };
65578     } catch (...) {
65579       {
65580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65581       };
65582     }
65583   }
65584
65585   jresult = result;
65586   return jresult;
65587 }
65588
65589
65590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65591   float jresult ;
65592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65593   float arg2 ;
65594   SwigDirector_ViewImpl *darg = 0;
65595   float result;
65596
65597   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65598   arg2 = (float)jarg2;
65599   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65600   if (!darg) {
65601     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65602     return 0;
65603   }
65604   {
65605     try {
65606       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65607     } catch (std::out_of_range& e) {
65608       {
65609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65610       };
65611     } catch (std::exception& e) {
65612       {
65613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65614       };
65615     } catch (Dali::DaliException e) {
65616       {
65617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65618       };
65619     } catch (...) {
65620       {
65621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65622       };
65623     }
65624   }
65625
65626   jresult = result;
65627   return jresult;
65628 }
65629
65630
65631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65632   float jresult ;
65633   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65634   float arg2 ;
65635   SwigDirector_ViewImpl *darg = 0;
65636   float result;
65637
65638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65639   arg2 = (float)jarg2;
65640   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65641   if (!darg) {
65642     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65643     return 0;
65644   }
65645   {
65646     try {
65647       result = (float)(darg)->GetWidthForHeight(arg2);
65648     } catch (std::out_of_range& e) {
65649       {
65650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65651       };
65652     } catch (std::exception& e) {
65653       {
65654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65655       };
65656     } catch (Dali::DaliException e) {
65657       {
65658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65659       };
65660     } catch (...) {
65661       {
65662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65663       };
65664     }
65665   }
65666
65667   jresult = result;
65668   return jresult;
65669 }
65670
65671
65672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65673   float jresult ;
65674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65675   float arg2 ;
65676   SwigDirector_ViewImpl *darg = 0;
65677   float result;
65678
65679   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65680   arg2 = (float)jarg2;
65681   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65682   if (!darg) {
65683     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65684     return 0;
65685   }
65686   {
65687     try {
65688       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65689     } catch (std::out_of_range& e) {
65690       {
65691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65692       };
65693     } catch (std::exception& e) {
65694       {
65695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65696       };
65697     } catch (Dali::DaliException e) {
65698       {
65699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65700       };
65701     } catch (...) {
65702       {
65703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65704       };
65705     }
65706   }
65707
65708   jresult = result;
65709   return jresult;
65710 }
65711
65712
65713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65714   unsigned int jresult ;
65715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65716   Dali::Dimension::Type arg2 ;
65717   SwigDirector_ViewImpl *darg = 0;
65718   bool result;
65719
65720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65721   arg2 = (Dali::Dimension::Type)jarg2;
65722   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65723   if (!darg) {
65724     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65725     return 0;
65726   }
65727   {
65728     try {
65729       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65730     } catch (std::out_of_range& e) {
65731       {
65732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65733       };
65734     } catch (std::exception& e) {
65735       {
65736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65737       };
65738     } catch (Dali::DaliException e) {
65739       {
65740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65741       };
65742     } catch (...) {
65743       {
65744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65745       };
65746     }
65747   }
65748
65749   jresult = result;
65750   return jresult;
65751 }
65752
65753
65754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65755   unsigned int jresult ;
65756   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65757   Dali::Dimension::Type arg2 ;
65758   SwigDirector_ViewImpl *darg = 0;
65759   bool result;
65760
65761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65762   arg2 = (Dali::Dimension::Type)jarg2;
65763   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65764   if (!darg) {
65765     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65766     return 0;
65767   }
65768   {
65769     try {
65770       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65771     } catch (std::out_of_range& e) {
65772       {
65773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65774       };
65775     } catch (std::exception& e) {
65776       {
65777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65778       };
65779     } catch (Dali::DaliException e) {
65780       {
65781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65782       };
65783     } catch (...) {
65784       {
65785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65786       };
65787     }
65788   }
65789
65790   jresult = result;
65791   return jresult;
65792 }
65793
65794
65795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65796   unsigned int jresult ;
65797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65798   SwigDirector_ViewImpl *darg = 0;
65799   bool result;
65800
65801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65802   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65803   if (!darg) {
65804     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65805     return 0;
65806   }
65807   {
65808     try {
65809       result = (bool)(darg)->RelayoutDependentOnChildren();
65810     } catch (std::out_of_range& e) {
65811       {
65812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65813       };
65814     } catch (std::exception& e) {
65815       {
65816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65817       };
65818     } catch (Dali::DaliException e) {
65819       {
65820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65821       };
65822     } catch (...) {
65823       {
65824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65825       };
65826     }
65827   }
65828
65829   jresult = result;
65830   return jresult;
65831 }
65832
65833
65834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65835   unsigned int jresult ;
65836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65837   SwigDirector_ViewImpl *darg = 0;
65838   bool result;
65839
65840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65841   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65842   if (!darg) {
65843     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65844     return 0;
65845   }
65846   {
65847     try {
65848       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65849     } catch (std::out_of_range& e) {
65850       {
65851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65852       };
65853     } catch (std::exception& e) {
65854       {
65855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65856       };
65857     } catch (Dali::DaliException e) {
65858       {
65859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65860       };
65861     } catch (...) {
65862       {
65863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65864       };
65865     }
65866   }
65867
65868   jresult = result;
65869   return jresult;
65870 }
65871
65872
65873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65875   Dali::Dimension::Type arg2 ;
65876   SwigDirector_ViewImpl *darg = 0;
65877
65878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65879   arg2 = (Dali::Dimension::Type)jarg2;
65880   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65881   if (!darg) {
65882     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65883     return;
65884   }
65885   {
65886     try {
65887       (darg)->OnCalculateRelayoutSize(arg2);
65888     } catch (std::out_of_range& e) {
65889       {
65890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65891       };
65892     } catch (std::exception& e) {
65893       {
65894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65895       };
65896     } catch (Dali::DaliException e) {
65897       {
65898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65899       };
65900     } catch (...) {
65901       {
65902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65903       };
65904     }
65905   }
65906
65907 }
65908
65909
65910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65912   Dali::Dimension::Type arg2 ;
65913   SwigDirector_ViewImpl *darg = 0;
65914
65915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65916   arg2 = (Dali::Dimension::Type)jarg2;
65917   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65918   if (!darg) {
65919     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65920     return;
65921   }
65922   {
65923     try {
65924       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65925     } catch (std::out_of_range& e) {
65926       {
65927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65928       };
65929     } catch (std::exception& e) {
65930       {
65931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65932       };
65933     } catch (Dali::DaliException e) {
65934       {
65935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65936       };
65937     } catch (...) {
65938       {
65939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65940       };
65941     }
65942   }
65943
65944 }
65945
65946
65947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65949   float arg2 ;
65950   Dali::Dimension::Type arg3 ;
65951   SwigDirector_ViewImpl *darg = 0;
65952
65953   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65954   arg2 = (float)jarg2;
65955   arg3 = (Dali::Dimension::Type)jarg3;
65956   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65957   if (!darg) {
65958     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65959     return;
65960   }
65961   {
65962     try {
65963       (darg)->OnLayoutNegotiated(arg2,arg3);
65964     } catch (std::out_of_range& e) {
65965       {
65966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65967       };
65968     } catch (std::exception& e) {
65969       {
65970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65971       };
65972     } catch (Dali::DaliException e) {
65973       {
65974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65975       };
65976     } catch (...) {
65977       {
65978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65979       };
65980     }
65981   }
65982
65983 }
65984
65985
65986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65988   float arg2 ;
65989   Dali::Dimension::Type arg3 ;
65990   SwigDirector_ViewImpl *darg = 0;
65991
65992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65993   arg2 = (float)jarg2;
65994   arg3 = (Dali::Dimension::Type)jarg3;
65995   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65996   if (!darg) {
65997     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65998     return;
65999   }
66000   {
66001     try {
66002       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
66003     } catch (std::out_of_range& e) {
66004       {
66005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66006       };
66007     } catch (std::exception& e) {
66008       {
66009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66010       };
66011     } catch (Dali::DaliException e) {
66012       {
66013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66014       };
66015     } catch (...) {
66016       {
66017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66018       };
66019     }
66020   }
66021
66022 }
66023
66024
66025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66027
66028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66029   {
66030     try {
66031       (arg1)->OnInitialize();
66032     } catch (std::out_of_range& e) {
66033       {
66034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66035       };
66036     } catch (std::exception& e) {
66037       {
66038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66039       };
66040     } catch (Dali::DaliException e) {
66041       {
66042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66043       };
66044     } catch (...) {
66045       {
66046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66047       };
66048     }
66049   }
66050
66051 }
66052
66053
66054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66056
66057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66058   {
66059     try {
66060       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66061     } catch (std::out_of_range& e) {
66062       {
66063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66064       };
66065     } catch (std::exception& e) {
66066       {
66067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66068       };
66069     } catch (Dali::DaliException e) {
66070       {
66071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66072       };
66073     } catch (...) {
66074       {
66075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66076       };
66077     }
66078   }
66079
66080 }
66081
66082
66083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66085   Dali::Actor *arg2 = 0 ;
66086
66087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66088   arg2 = (Dali::Actor *)jarg2;
66089   if (!arg2) {
66090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66091     return ;
66092   }
66093   {
66094     try {
66095       (arg1)->OnControlChildAdd(*arg2);
66096     } catch (std::out_of_range& e) {
66097       {
66098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66099       };
66100     } catch (std::exception& e) {
66101       {
66102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66103       };
66104     } catch (Dali::DaliException e) {
66105       {
66106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66107       };
66108     } catch (...) {
66109       {
66110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66111       };
66112     }
66113   }
66114
66115 }
66116
66117
66118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66119   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66120   Dali::Actor *arg2 = 0 ;
66121
66122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66123   arg2 = (Dali::Actor *)jarg2;
66124   if (!arg2) {
66125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66126     return ;
66127   }
66128   {
66129     try {
66130       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66131     } catch (std::out_of_range& e) {
66132       {
66133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66134       };
66135     } catch (std::exception& e) {
66136       {
66137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66138       };
66139     } catch (Dali::DaliException e) {
66140       {
66141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66142       };
66143     } catch (...) {
66144       {
66145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66146       };
66147     }
66148   }
66149
66150 }
66151
66152
66153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66155   Dali::Actor *arg2 = 0 ;
66156
66157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66158   arg2 = (Dali::Actor *)jarg2;
66159   if (!arg2) {
66160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66161     return ;
66162   }
66163   {
66164     try {
66165       (arg1)->OnControlChildRemove(*arg2);
66166     } catch (std::out_of_range& e) {
66167       {
66168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66169       };
66170     } catch (std::exception& e) {
66171       {
66172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66173       };
66174     } catch (Dali::DaliException e) {
66175       {
66176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66177       };
66178     } catch (...) {
66179       {
66180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66181       };
66182     }
66183   }
66184
66185 }
66186
66187
66188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66189   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66190   Dali::Actor *arg2 = 0 ;
66191
66192   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66193   arg2 = (Dali::Actor *)jarg2;
66194   if (!arg2) {
66195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66196     return ;
66197   }
66198   {
66199     try {
66200       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66201     } catch (std::out_of_range& e) {
66202       {
66203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66204       };
66205     } catch (std::exception& e) {
66206       {
66207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66208       };
66209     } catch (Dali::DaliException e) {
66210       {
66211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66212       };
66213     } catch (...) {
66214       {
66215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66216       };
66217     }
66218   }
66219
66220 }
66221
66222
66223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66224   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66225   Dali::Toolkit::StyleManager arg2 ;
66226   Dali::StyleChange::Type arg3 ;
66227   Dali::Toolkit::StyleManager *argp2 ;
66228
66229   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66230   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66231   if (!argp2) {
66232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66233     return ;
66234   }
66235   arg2 = *argp2;
66236   arg3 = (Dali::StyleChange::Type)jarg3;
66237   {
66238     try {
66239       (arg1)->OnStyleChange(arg2,arg3);
66240     } catch (std::out_of_range& e) {
66241       {
66242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66243       };
66244     } catch (std::exception& e) {
66245       {
66246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66247       };
66248     } catch (Dali::DaliException e) {
66249       {
66250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66251       };
66252     } catch (...) {
66253       {
66254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66255       };
66256     }
66257   }
66258
66259 }
66260
66261
66262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66263   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66264   Dali::Toolkit::StyleManager arg2 ;
66265   Dali::StyleChange::Type arg3 ;
66266   Dali::Toolkit::StyleManager *argp2 ;
66267
66268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66269   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66270   if (!argp2) {
66271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66272     return ;
66273   }
66274   arg2 = *argp2;
66275   arg3 = (Dali::StyleChange::Type)jarg3;
66276   {
66277     try {
66278       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66279     } catch (std::out_of_range& e) {
66280       {
66281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66282       };
66283     } catch (std::exception& e) {
66284       {
66285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66286       };
66287     } catch (Dali::DaliException e) {
66288       {
66289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66290       };
66291     } catch (...) {
66292       {
66293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66294       };
66295     }
66296   }
66297
66298 }
66299
66300
66301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66302   unsigned int jresult ;
66303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66304   bool result;
66305
66306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66307   {
66308     try {
66309       result = (bool)(arg1)->OnAccessibilityActivated();
66310     } catch (std::out_of_range& e) {
66311       {
66312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66313       };
66314     } catch (std::exception& e) {
66315       {
66316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66317       };
66318     } catch (Dali::DaliException e) {
66319       {
66320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66321       };
66322     } catch (...) {
66323       {
66324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66325       };
66326     }
66327   }
66328
66329   jresult = result;
66330   return jresult;
66331 }
66332
66333
66334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66335   unsigned int jresult ;
66336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66337   bool result;
66338
66339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66340   {
66341     try {
66342       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66343     } catch (std::out_of_range& e) {
66344       {
66345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66346       };
66347     } catch (std::exception& e) {
66348       {
66349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66350       };
66351     } catch (Dali::DaliException e) {
66352       {
66353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66354       };
66355     } catch (...) {
66356       {
66357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66358       };
66359     }
66360   }
66361
66362   jresult = result;
66363   return jresult;
66364 }
66365
66366
66367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66368   unsigned int jresult ;
66369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66370   Dali::PanGesture arg2 ;
66371   Dali::PanGesture *argp2 ;
66372   bool result;
66373
66374   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66375   argp2 = (Dali::PanGesture *)jarg2;
66376   if (!argp2) {
66377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66378     return 0;
66379   }
66380   arg2 = *argp2;
66381   {
66382     try {
66383       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66384     } catch (std::out_of_range& e) {
66385       {
66386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66387       };
66388     } catch (std::exception& e) {
66389       {
66390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66391       };
66392     } catch (Dali::DaliException e) {
66393       {
66394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66395       };
66396     } catch (...) {
66397       {
66398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66399       };
66400     }
66401   }
66402
66403   jresult = result;
66404   return jresult;
66405 }
66406
66407
66408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66409   unsigned int jresult ;
66410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66411   Dali::PanGesture arg2 ;
66412   Dali::PanGesture *argp2 ;
66413   bool result;
66414
66415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66416   argp2 = (Dali::PanGesture *)jarg2;
66417   if (!argp2) {
66418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66419     return 0;
66420   }
66421   arg2 = *argp2;
66422   {
66423     try {
66424       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66425     } catch (std::out_of_range& e) {
66426       {
66427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66428       };
66429     } catch (std::exception& e) {
66430       {
66431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66432       };
66433     } catch (Dali::DaliException e) {
66434       {
66435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66436       };
66437     } catch (...) {
66438       {
66439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66440       };
66441     }
66442   }
66443
66444   jresult = result;
66445   return jresult;
66446 }
66447
66448
66449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66450   unsigned int jresult ;
66451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66452   Dali::TouchEvent *arg2 = 0 ;
66453   bool result;
66454
66455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66456   arg2 = (Dali::TouchEvent *)jarg2;
66457   if (!arg2) {
66458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66459     return 0;
66460   }
66461   {
66462     try {
66463       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66464     } catch (std::out_of_range& e) {
66465       {
66466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66467       };
66468     } catch (std::exception& e) {
66469       {
66470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66471       };
66472     } catch (Dali::DaliException e) {
66473       {
66474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66475       };
66476     } catch (...) {
66477       {
66478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66479       };
66480     }
66481   }
66482
66483   jresult = result;
66484   return jresult;
66485 }
66486
66487
66488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66489   unsigned int jresult ;
66490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66491   Dali::TouchEvent *arg2 = 0 ;
66492   bool result;
66493
66494   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66495   arg2 = (Dali::TouchEvent *)jarg2;
66496   if (!arg2) {
66497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66498     return 0;
66499   }
66500   {
66501     try {
66502       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66503     } catch (std::out_of_range& e) {
66504       {
66505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66506       };
66507     } catch (std::exception& e) {
66508       {
66509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66510       };
66511     } catch (Dali::DaliException e) {
66512       {
66513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66514       };
66515     } catch (...) {
66516       {
66517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66518       };
66519     }
66520   }
66521
66522   jresult = result;
66523   return jresult;
66524 }
66525
66526
66527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66528   unsigned int jresult ;
66529   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66530   bool arg2 ;
66531   bool result;
66532
66533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66534   arg2 = jarg2 ? true : false;
66535   {
66536     try {
66537       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66538     } catch (std::out_of_range& e) {
66539       {
66540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66541       };
66542     } catch (std::exception& e) {
66543       {
66544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66545       };
66546     } catch (Dali::DaliException e) {
66547       {
66548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66549       };
66550     } catch (...) {
66551       {
66552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66553       };
66554     }
66555   }
66556
66557   jresult = result;
66558   return jresult;
66559 }
66560
66561
66562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66563   unsigned int jresult ;
66564   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66565   bool arg2 ;
66566   bool result;
66567
66568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66569   arg2 = jarg2 ? true : false;
66570   {
66571     try {
66572       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66573     } catch (std::out_of_range& e) {
66574       {
66575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66576       };
66577     } catch (std::exception& e) {
66578       {
66579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66580       };
66581     } catch (Dali::DaliException e) {
66582       {
66583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66584       };
66585     } catch (...) {
66586       {
66587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66588       };
66589     }
66590   }
66591
66592   jresult = result;
66593   return jresult;
66594 }
66595
66596
66597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66598   unsigned int jresult ;
66599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66600   bool result;
66601
66602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66603   {
66604     try {
66605       result = (bool)(arg1)->OnAccessibilityZoom();
66606     } catch (std::out_of_range& e) {
66607       {
66608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66609       };
66610     } catch (std::exception& e) {
66611       {
66612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66613       };
66614     } catch (Dali::DaliException e) {
66615       {
66616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66617       };
66618     } catch (...) {
66619       {
66620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66621       };
66622     }
66623   }
66624
66625   jresult = result;
66626   return jresult;
66627 }
66628
66629
66630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66631   unsigned int jresult ;
66632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66633   bool result;
66634
66635   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66636   {
66637     try {
66638       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66639     } catch (std::out_of_range& e) {
66640       {
66641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66642       };
66643     } catch (std::exception& e) {
66644       {
66645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66646       };
66647     } catch (Dali::DaliException e) {
66648       {
66649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66650       };
66651     } catch (...) {
66652       {
66653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66654       };
66655     }
66656   }
66657
66658   jresult = result;
66659   return jresult;
66660 }
66661
66662
66663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66665
66666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66667   {
66668     try {
66669       (arg1)->OnKeyInputFocusGained();
66670     } catch (std::out_of_range& e) {
66671       {
66672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66673       };
66674     } catch (std::exception& e) {
66675       {
66676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66677       };
66678     } catch (Dali::DaliException e) {
66679       {
66680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66681       };
66682     } catch (...) {
66683       {
66684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66685       };
66686     }
66687   }
66688
66689 }
66690
66691
66692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66694
66695   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66696   {
66697     try {
66698       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66699     } catch (std::out_of_range& e) {
66700       {
66701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66702       };
66703     } catch (std::exception& e) {
66704       {
66705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66706       };
66707     } catch (Dali::DaliException e) {
66708       {
66709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66710       };
66711     } catch (...) {
66712       {
66713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66714       };
66715     }
66716   }
66717
66718 }
66719
66720
66721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66723
66724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66725   {
66726     try {
66727       (arg1)->OnKeyInputFocusLost();
66728     } catch (std::out_of_range& e) {
66729       {
66730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66731       };
66732     } catch (std::exception& e) {
66733       {
66734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66735       };
66736     } catch (Dali::DaliException e) {
66737       {
66738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66739       };
66740     } catch (...) {
66741       {
66742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66743       };
66744     }
66745   }
66746
66747 }
66748
66749
66750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66751   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66752
66753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66754   {
66755     try {
66756       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66757     } catch (std::out_of_range& e) {
66758       {
66759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66760       };
66761     } catch (std::exception& e) {
66762       {
66763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66764       };
66765     } catch (Dali::DaliException e) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66768       };
66769     } catch (...) {
66770       {
66771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66772       };
66773     }
66774   }
66775
66776 }
66777
66778
66779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66780   void * jresult ;
66781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66782   Dali::Actor arg2 ;
66783   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66784   bool arg4 ;
66785   Dali::Actor *argp2 ;
66786   Dali::Actor result;
66787
66788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66789   argp2 = (Dali::Actor *)jarg2;
66790   if (!argp2) {
66791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66792     return 0;
66793   }
66794   arg2 = *argp2;
66795   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66796   arg4 = jarg4 ? true : false;
66797   {
66798     try {
66799       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66800     } catch (std::out_of_range& e) {
66801       {
66802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66803       };
66804     } catch (std::exception& e) {
66805       {
66806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66807       };
66808     } catch (Dali::DaliException e) {
66809       {
66810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66811       };
66812     } catch (...) {
66813       {
66814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66815       };
66816     }
66817   }
66818
66819   jresult = new Dali::Actor((const Dali::Actor &)result);
66820   return jresult;
66821 }
66822
66823
66824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66825   void * jresult ;
66826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66827   Dali::Actor arg2 ;
66828   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66829   bool arg4 ;
66830   Dali::Actor *argp2 ;
66831   Dali::Actor result;
66832
66833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66834   argp2 = (Dali::Actor *)jarg2;
66835   if (!argp2) {
66836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66837     return 0;
66838   }
66839   arg2 = *argp2;
66840   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66841   arg4 = jarg4 ? true : false;
66842   {
66843     try {
66844       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66845     } catch (std::out_of_range& e) {
66846       {
66847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66848       };
66849     } catch (std::exception& e) {
66850       {
66851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66852       };
66853     } catch (Dali::DaliException e) {
66854       {
66855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66856       };
66857     } catch (...) {
66858       {
66859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66860       };
66861     }
66862   }
66863
66864   jresult = new Dali::Actor((const Dali::Actor &)result);
66865   return jresult;
66866 }
66867
66868
66869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66871   Dali::Actor arg2 ;
66872   Dali::Actor *argp2 ;
66873
66874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66875   argp2 = (Dali::Actor *)jarg2;
66876   if (!argp2) {
66877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66878     return ;
66879   }
66880   arg2 = *argp2;
66881   {
66882     try {
66883       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66884     } catch (std::out_of_range& e) {
66885       {
66886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66887       };
66888     } catch (std::exception& e) {
66889       {
66890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66891       };
66892     } catch (Dali::DaliException e) {
66893       {
66894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66895       };
66896     } catch (...) {
66897       {
66898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66899       };
66900     }
66901   }
66902
66903 }
66904
66905
66906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66908   Dali::Actor arg2 ;
66909   Dali::Actor *argp2 ;
66910
66911   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66912   argp2 = (Dali::Actor *)jarg2;
66913   if (!argp2) {
66914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66915     return ;
66916   }
66917   arg2 = *argp2;
66918   {
66919     try {
66920       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66921     } catch (std::out_of_range& e) {
66922       {
66923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66924       };
66925     } catch (std::exception& e) {
66926       {
66927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66928       };
66929     } catch (Dali::DaliException e) {
66930       {
66931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66932       };
66933     } catch (...) {
66934       {
66935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66936       };
66937     }
66938   }
66939
66940 }
66941
66942
66943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66944   unsigned int jresult ;
66945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66946   bool result;
66947
66948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66949   {
66950     try {
66951       result = (bool)(arg1)->OnKeyboardEnter();
66952     } catch (std::out_of_range& e) {
66953       {
66954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66955       };
66956     } catch (std::exception& e) {
66957       {
66958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66959       };
66960     } catch (Dali::DaliException e) {
66961       {
66962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66963       };
66964     } catch (...) {
66965       {
66966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66967       };
66968     }
66969   }
66970
66971   jresult = result;
66972   return jresult;
66973 }
66974
66975
66976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66977   unsigned int jresult ;
66978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66979   bool result;
66980
66981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66982   {
66983     try {
66984       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66985     } catch (std::out_of_range& e) {
66986       {
66987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66988       };
66989     } catch (std::exception& e) {
66990       {
66991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66992       };
66993     } catch (Dali::DaliException e) {
66994       {
66995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66996       };
66997     } catch (...) {
66998       {
66999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67000       };
67001     }
67002   }
67003
67004   jresult = result;
67005   return jresult;
67006 }
67007
67008
67009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
67010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67011   Dali::PinchGesture *arg2 = 0 ;
67012
67013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67014   arg2 = (Dali::PinchGesture *)jarg2;
67015   if (!arg2) {
67016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67017     return ;
67018   }
67019   {
67020     try {
67021       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67022     } catch (std::out_of_range& e) {
67023       {
67024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67025       };
67026     } catch (std::exception& e) {
67027       {
67028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67029       };
67030     } catch (Dali::DaliException e) {
67031       {
67032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67033       };
67034     } catch (...) {
67035       {
67036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67037       };
67038     }
67039   }
67040
67041 }
67042
67043
67044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67046   Dali::PinchGesture *arg2 = 0 ;
67047
67048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67049   arg2 = (Dali::PinchGesture *)jarg2;
67050   if (!arg2) {
67051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67052     return ;
67053   }
67054   {
67055     try {
67056       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67057     } catch (std::out_of_range& e) {
67058       {
67059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67060       };
67061     } catch (std::exception& e) {
67062       {
67063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67064       };
67065     } catch (Dali::DaliException e) {
67066       {
67067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67068       };
67069     } catch (...) {
67070       {
67071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67072       };
67073     }
67074   }
67075
67076 }
67077
67078
67079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67080   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67081   Dali::PanGesture *arg2 = 0 ;
67082
67083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67084   arg2 = (Dali::PanGesture *)jarg2;
67085   if (!arg2) {
67086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67087     return ;
67088   }
67089   {
67090     try {
67091       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67092     } catch (std::out_of_range& e) {
67093       {
67094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67095       };
67096     } catch (std::exception& e) {
67097       {
67098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67099       };
67100     } catch (Dali::DaliException e) {
67101       {
67102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67103       };
67104     } catch (...) {
67105       {
67106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67107       };
67108     }
67109   }
67110
67111 }
67112
67113
67114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67116   Dali::PanGesture *arg2 = 0 ;
67117
67118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67119   arg2 = (Dali::PanGesture *)jarg2;
67120   if (!arg2) {
67121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67122     return ;
67123   }
67124   {
67125     try {
67126       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67127     } catch (std::out_of_range& e) {
67128       {
67129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67130       };
67131     } catch (std::exception& e) {
67132       {
67133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67134       };
67135     } catch (Dali::DaliException e) {
67136       {
67137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67138       };
67139     } catch (...) {
67140       {
67141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67142       };
67143     }
67144   }
67145
67146 }
67147
67148
67149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67151   Dali::TapGesture *arg2 = 0 ;
67152
67153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67154   arg2 = (Dali::TapGesture *)jarg2;
67155   if (!arg2) {
67156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67157     return ;
67158   }
67159   {
67160     try {
67161       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67162     } catch (std::out_of_range& e) {
67163       {
67164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67165       };
67166     } catch (std::exception& e) {
67167       {
67168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67169       };
67170     } catch (Dali::DaliException e) {
67171       {
67172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67173       };
67174     } catch (...) {
67175       {
67176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67177       };
67178     }
67179   }
67180
67181 }
67182
67183
67184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67186   Dali::TapGesture *arg2 = 0 ;
67187
67188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67189   arg2 = (Dali::TapGesture *)jarg2;
67190   if (!arg2) {
67191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67192     return ;
67193   }
67194   {
67195     try {
67196       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67197     } catch (std::out_of_range& e) {
67198       {
67199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67200       };
67201     } catch (std::exception& e) {
67202       {
67203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67204       };
67205     } catch (Dali::DaliException e) {
67206       {
67207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67208       };
67209     } catch (...) {
67210       {
67211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67212       };
67213     }
67214   }
67215
67216 }
67217
67218
67219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67221   Dali::LongPressGesture *arg2 = 0 ;
67222
67223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67224   arg2 = (Dali::LongPressGesture *)jarg2;
67225   if (!arg2) {
67226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67227     return ;
67228   }
67229   {
67230     try {
67231       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67232     } catch (std::out_of_range& e) {
67233       {
67234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67235       };
67236     } catch (std::exception& e) {
67237       {
67238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67239       };
67240     } catch (Dali::DaliException e) {
67241       {
67242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67243       };
67244     } catch (...) {
67245       {
67246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67247       };
67248     }
67249   }
67250
67251 }
67252
67253
67254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67256   Dali::LongPressGesture *arg2 = 0 ;
67257
67258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67259   arg2 = (Dali::LongPressGesture *)jarg2;
67260   if (!arg2) {
67261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67262     return ;
67263   }
67264   {
67265     try {
67266       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67267     } catch (std::out_of_range& e) {
67268       {
67269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67270       };
67271     } catch (std::exception& e) {
67272       {
67273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67274       };
67275     } catch (Dali::DaliException e) {
67276       {
67277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67278       };
67279     } catch (...) {
67280       {
67281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67282       };
67283     }
67284   }
67285
67286 }
67287
67288
67289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67291   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67292   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67293
67294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67295   arg2 = (Dali::SlotObserver *)jarg2;
67296   arg3 = (Dali::CallbackBase *)jarg3;
67297   {
67298     try {
67299       (arg1)->SignalConnected(arg2,arg3);
67300     } catch (std::out_of_range& e) {
67301       {
67302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67303       };
67304     } catch (std::exception& e) {
67305       {
67306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67307       };
67308     } catch (Dali::DaliException e) {
67309       {
67310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67311       };
67312     } catch (...) {
67313       {
67314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67315       };
67316     }
67317   }
67318
67319 }
67320
67321
67322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67324   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67325   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67326
67327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67328   arg2 = (Dali::SlotObserver *)jarg2;
67329   arg3 = (Dali::CallbackBase *)jarg3;
67330   {
67331     try {
67332       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67333     } catch (std::out_of_range& e) {
67334       {
67335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67336       };
67337     } catch (std::exception& e) {
67338       {
67339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67340       };
67341     } catch (Dali::DaliException e) {
67342       {
67343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67344       };
67345     } catch (...) {
67346       {
67347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67348       };
67349     }
67350   }
67351
67352 }
67353
67354
67355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67357   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67358   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67359
67360   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67361   arg2 = (Dali::SlotObserver *)jarg2;
67362   arg3 = (Dali::CallbackBase *)jarg3;
67363   {
67364     try {
67365       (arg1)->SignalDisconnected(arg2,arg3);
67366     } catch (std::out_of_range& e) {
67367       {
67368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67369       };
67370     } catch (std::exception& e) {
67371       {
67372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67373       };
67374     } catch (Dali::DaliException e) {
67375       {
67376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67377       };
67378     } catch (...) {
67379       {
67380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67381       };
67382     }
67383   }
67384
67385 }
67386
67387
67388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67390   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67391   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67392
67393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67394   arg2 = (Dali::SlotObserver *)jarg2;
67395   arg3 = (Dali::CallbackBase *)jarg3;
67396   {
67397     try {
67398       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67399     } catch (std::out_of_range& e) {
67400       {
67401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67402       };
67403     } catch (std::exception& e) {
67404       {
67405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67406       };
67407     } catch (Dali::DaliException e) {
67408       {
67409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67410       };
67411     } catch (...) {
67412       {
67413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67414       };
67415     }
67416   }
67417
67418 }
67419
67420
67421 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) {
67422   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67423   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67424   if (director) {
67425     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);
67426   }
67427 }
67428
67429
67430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67431   void * jresult ;
67432   Dali::Toolkit::Control *arg1 = 0 ;
67433   Dali::Toolkit::Internal::Control *result = 0 ;
67434
67435   arg1 = (Dali::Toolkit::Control *)jarg1;
67436   if (!arg1) {
67437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67438     return 0;
67439   }
67440   {
67441     try {
67442       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67443     } catch (std::out_of_range& e) {
67444       {
67445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67446       };
67447     } catch (std::exception& e) {
67448       {
67449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67450       };
67451     } catch (Dali::DaliException e) {
67452       {
67453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67454       };
67455     } catch (...) {
67456       {
67457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67458       };
67459     }
67460   }
67461
67462   jresult = (void *)result;
67463   return jresult;
67464 }
67465
67466
67467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67468   int jresult ;
67469   int result;
67470
67471   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67472   jresult = (int)result;
67473   return jresult;
67474 }
67475
67476
67477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67478   int jresult ;
67479   int result;
67480
67481   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67482   jresult = (int)result;
67483   return jresult;
67484 }
67485
67486
67487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67488   int jresult ;
67489   int result;
67490
67491   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67492   jresult = (int)result;
67493   return jresult;
67494 }
67495
67496
67497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67498   int jresult ;
67499   int result;
67500
67501   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67502   jresult = (int)result;
67503   return jresult;
67504 }
67505
67506
67507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67508   int jresult ;
67509   int result;
67510
67511   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67512   jresult = (int)result;
67513   return jresult;
67514 }
67515
67516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67517   int jresult ;
67518   int result;
67519
67520   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67521   jresult = (int)result;
67522   return jresult;
67523 }
67524
67525
67526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67527   int jresult ;
67528   int result;
67529
67530   result = (int)Dali::Toolkit::Control::Property::PADDING;
67531   jresult = (int)result;
67532   return jresult;
67533 }
67534
67535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67536   void * jresult ;
67537   Dali::Toolkit::Control::Property *result = 0 ;
67538
67539   {
67540     try {
67541       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67542     } catch (std::out_of_range& e) {
67543       {
67544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67545       };
67546     } catch (std::exception& e) {
67547       {
67548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67549       };
67550     } catch (Dali::DaliException e) {
67551       {
67552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67553       };
67554     } catch (...) {
67555       {
67556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67557       };
67558     }
67559   }
67560
67561   jresult = (void *)result;
67562   return jresult;
67563 }
67564
67565
67566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67567   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67568
67569   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67570   {
67571     try {
67572       delete arg1;
67573     } catch (std::out_of_range& e) {
67574       {
67575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67576       };
67577     } catch (std::exception& e) {
67578       {
67579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67580       };
67581     } catch (Dali::DaliException e) {
67582       {
67583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67584       };
67585     } catch (...) {
67586       {
67587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67588       };
67589     }
67590   }
67591
67592 }
67593
67594
67595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67596   void * jresult ;
67597   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67598
67599   {
67600     try {
67601       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67602     } catch (std::out_of_range& e) {
67603       {
67604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67605       };
67606     } catch (std::exception& e) {
67607       {
67608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67609       };
67610     } catch (Dali::DaliException e) {
67611       {
67612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67613       };
67614     } catch (...) {
67615       {
67616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67617       };
67618     }
67619   }
67620
67621   jresult = (void *)result;
67622   return jresult;
67623 }
67624
67625
67626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67627   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67628
67629   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67630   {
67631     try {
67632       delete arg1;
67633     } catch (std::out_of_range& e) {
67634       {
67635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67636       };
67637     } catch (std::exception& e) {
67638       {
67639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67640       };
67641     } catch (Dali::DaliException e) {
67642       {
67643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67644       };
67645     } catch (...) {
67646       {
67647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67648       };
67649     }
67650   }
67651
67652 }
67653
67654
67655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67656   void * jresult ;
67657   Dali::Toolkit::Control result;
67658
67659   {
67660     try {
67661       result = Dali::Toolkit::Control::New();
67662     } catch (std::out_of_range& e) {
67663       {
67664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67665       };
67666     } catch (std::exception& e) {
67667       {
67668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67669       };
67670     } catch (Dali::DaliException e) {
67671       {
67672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67673       };
67674     } catch (...) {
67675       {
67676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67677       };
67678     }
67679   }
67680
67681   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67682   return jresult;
67683 }
67684
67685
67686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67687   void * jresult ;
67688   Dali::Toolkit::Control *result = 0 ;
67689
67690   {
67691     try {
67692       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67693     } catch (std::out_of_range& e) {
67694       {
67695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67696       };
67697     } catch (std::exception& e) {
67698       {
67699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67700       };
67701     } catch (Dali::DaliException e) {
67702       {
67703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67704       };
67705     } catch (...) {
67706       {
67707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67708       };
67709     }
67710   }
67711
67712   jresult = (void *)result;
67713   return jresult;
67714 }
67715
67716
67717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67718   void * jresult ;
67719   Dali::Toolkit::Control *arg1 = 0 ;
67720   Dali::Toolkit::Control *result = 0 ;
67721
67722   arg1 = (Dali::Toolkit::Control *)jarg1;
67723   if (!arg1) {
67724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67725     return 0;
67726   }
67727   {
67728     try {
67729       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67730     } catch (std::out_of_range& e) {
67731       {
67732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67733       };
67734     } catch (std::exception& e) {
67735       {
67736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67737       };
67738     } catch (Dali::DaliException e) {
67739       {
67740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67741       };
67742     } catch (...) {
67743       {
67744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67745       };
67746     }
67747   }
67748
67749   jresult = (void *)result;
67750   return jresult;
67751 }
67752
67753
67754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67755   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67756
67757   arg1 = (Dali::Toolkit::Control *)jarg1;
67758   {
67759     try {
67760       delete arg1;
67761     } catch (std::out_of_range& e) {
67762       {
67763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67764       };
67765     } catch (std::exception& e) {
67766       {
67767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67768       };
67769     } catch (Dali::DaliException e) {
67770       {
67771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67772       };
67773     } catch (...) {
67774       {
67775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67776       };
67777     }
67778   }
67779
67780 }
67781
67782
67783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67784   void * jresult ;
67785   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67786   Dali::Toolkit::Control *arg2 = 0 ;
67787   Dali::Toolkit::Control *result = 0 ;
67788
67789   arg1 = (Dali::Toolkit::Control *)jarg1;
67790   arg2 = (Dali::Toolkit::Control *)jarg2;
67791   if (!arg2) {
67792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67793     return 0;
67794   }
67795   {
67796     try {
67797       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67798     } catch (std::out_of_range& e) {
67799       {
67800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67801       };
67802     } catch (std::exception& e) {
67803       {
67804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67805       };
67806     } catch (Dali::DaliException e) {
67807       {
67808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67809       };
67810     } catch (...) {
67811       {
67812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67813       };
67814     }
67815   }
67816
67817   jresult = (void *)result;
67818   return jresult;
67819 }
67820
67821
67822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67823   void * jresult ;
67824   Dali::BaseHandle arg1 ;
67825   Dali::BaseHandle *argp1 ;
67826   Dali::Toolkit::Control result;
67827
67828   argp1 = (Dali::BaseHandle *)jarg1;
67829   if (!argp1) {
67830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67831     return 0;
67832   }
67833   arg1 = *argp1;
67834   {
67835     try {
67836       result = Dali::Toolkit::Control::DownCast(arg1);
67837     } catch (std::out_of_range& e) {
67838       {
67839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67840       };
67841     } catch (std::exception& e) {
67842       {
67843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67844       };
67845     } catch (Dali::DaliException e) {
67846       {
67847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67848       };
67849     } catch (...) {
67850       {
67851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67852       };
67853     }
67854   }
67855
67856   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67857   return jresult;
67858 }
67859
67860
67861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67862   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67863
67864   arg1 = (Dali::Toolkit::Control *)jarg1;
67865   {
67866     try {
67867       (arg1)->SetKeyInputFocus();
67868     } catch (std::out_of_range& e) {
67869       {
67870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67871       };
67872     } catch (std::exception& e) {
67873       {
67874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67875       };
67876     } catch (Dali::DaliException e) {
67877       {
67878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67879       };
67880     } catch (...) {
67881       {
67882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67883       };
67884     }
67885   }
67886
67887 }
67888
67889
67890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67891   unsigned int jresult ;
67892   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67893   bool result;
67894
67895   arg1 = (Dali::Toolkit::Control *)jarg1;
67896   {
67897     try {
67898       result = (bool)(arg1)->HasKeyInputFocus();
67899     } catch (std::out_of_range& e) {
67900       {
67901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67902       };
67903     } catch (std::exception& e) {
67904       {
67905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67906       };
67907     } catch (Dali::DaliException e) {
67908       {
67909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67910       };
67911     } catch (...) {
67912       {
67913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67914       };
67915     }
67916   }
67917
67918   jresult = result;
67919   return jresult;
67920 }
67921
67922
67923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67924   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67925
67926   arg1 = (Dali::Toolkit::Control *)jarg1;
67927   {
67928     try {
67929       (arg1)->ClearKeyInputFocus();
67930     } catch (std::out_of_range& e) {
67931       {
67932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67933       };
67934     } catch (std::exception& e) {
67935       {
67936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67937       };
67938     } catch (Dali::DaliException e) {
67939       {
67940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67941       };
67942     } catch (...) {
67943       {
67944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67945       };
67946     }
67947   }
67948
67949 }
67950
67951
67952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67953   void * jresult ;
67954   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67955   Dali::PinchGestureDetector result;
67956
67957   arg1 = (Dali::Toolkit::Control *)jarg1;
67958   {
67959     try {
67960       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67961     } catch (std::out_of_range& e) {
67962       {
67963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67964       };
67965     } catch (std::exception& e) {
67966       {
67967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67968       };
67969     } catch (Dali::DaliException e) {
67970       {
67971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67972       };
67973     } catch (...) {
67974       {
67975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67976       };
67977     }
67978   }
67979
67980   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67981   return jresult;
67982 }
67983
67984
67985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67986   void * jresult ;
67987   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67988   Dali::PanGestureDetector result;
67989
67990   arg1 = (Dali::Toolkit::Control *)jarg1;
67991   {
67992     try {
67993       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67994     } catch (std::out_of_range& e) {
67995       {
67996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67997       };
67998     } catch (std::exception& e) {
67999       {
68000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68001       };
68002     } catch (Dali::DaliException e) {
68003       {
68004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68005       };
68006     } catch (...) {
68007       {
68008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68009       };
68010     }
68011   }
68012
68013   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68014   return jresult;
68015 }
68016
68017
68018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68019   void * jresult ;
68020   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68021   Dali::TapGestureDetector result;
68022
68023   arg1 = (Dali::Toolkit::Control *)jarg1;
68024   {
68025     try {
68026       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68027     } catch (std::out_of_range& e) {
68028       {
68029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68030       };
68031     } catch (std::exception& e) {
68032       {
68033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68034       };
68035     } catch (Dali::DaliException e) {
68036       {
68037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68038       };
68039     } catch (...) {
68040       {
68041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68042       };
68043     }
68044   }
68045
68046   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68047   return jresult;
68048 }
68049
68050
68051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68052   void * jresult ;
68053   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68054   Dali::LongPressGestureDetector result;
68055
68056   arg1 = (Dali::Toolkit::Control *)jarg1;
68057   {
68058     try {
68059       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68060     } catch (std::out_of_range& e) {
68061       {
68062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68063       };
68064     } catch (std::exception& e) {
68065       {
68066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68067       };
68068     } catch (Dali::DaliException e) {
68069       {
68070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68071       };
68072     } catch (...) {
68073       {
68074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68075       };
68076     }
68077   }
68078
68079   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68080   return jresult;
68081 }
68082
68083
68084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68085   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68086   std::string *arg2 = 0 ;
68087
68088   arg1 = (Dali::Toolkit::Control *)jarg1;
68089   if (!jarg2) {
68090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68091     return ;
68092   }
68093   std::string arg2_str(jarg2);
68094   arg2 = &arg2_str;
68095   {
68096     try {
68097       (arg1)->SetStyleName((std::string const &)*arg2);
68098     } catch (std::out_of_range& e) {
68099       {
68100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68101       };
68102     } catch (std::exception& e) {
68103       {
68104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68105       };
68106     } catch (Dali::DaliException e) {
68107       {
68108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68109       };
68110     } catch (...) {
68111       {
68112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68113       };
68114     }
68115   }
68116
68117
68118   //argout typemap for const std::string&
68119
68120 }
68121
68122
68123 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68124   char * jresult ;
68125   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68126   std::string *result = 0 ;
68127
68128   arg1 = (Dali::Toolkit::Control *)jarg1;
68129   {
68130     try {
68131       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68132     } catch (std::out_of_range& e) {
68133       {
68134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68135       };
68136     } catch (std::exception& e) {
68137       {
68138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68139       };
68140     } catch (Dali::DaliException e) {
68141       {
68142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68143       };
68144     } catch (...) {
68145       {
68146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68147       };
68148     }
68149   }
68150
68151   jresult = SWIG_csharp_string_callback(result->c_str());
68152   return jresult;
68153 }
68154
68155
68156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68157   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68158   Dali::Vector4 *arg2 = 0 ;
68159
68160   arg1 = (Dali::Toolkit::Control *)jarg1;
68161   arg2 = (Dali::Vector4 *)jarg2;
68162   if (!arg2) {
68163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68164     return ;
68165   }
68166   {
68167     try {
68168       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68169     } catch (std::out_of_range& e) {
68170       {
68171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68172       };
68173     } catch (std::exception& e) {
68174       {
68175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68176       };
68177     } catch (Dali::DaliException e) {
68178       {
68179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68180       };
68181     } catch (...) {
68182       {
68183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68184       };
68185     }
68186   }
68187
68188 }
68189
68190
68191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68192   void * jresult ;
68193   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68194   Dali::Vector4 result;
68195
68196   arg1 = (Dali::Toolkit::Control *)jarg1;
68197   {
68198     try {
68199       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68200     } catch (std::out_of_range& e) {
68201       {
68202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68203       };
68204     } catch (std::exception& e) {
68205       {
68206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68207       };
68208     } catch (Dali::DaliException e) {
68209       {
68210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68211       };
68212     } catch (...) {
68213       {
68214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68215       };
68216     }
68217   }
68218
68219   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68220   return jresult;
68221 }
68222
68223
68224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68225   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68226   Dali::Image arg2 ;
68227   Dali::Image *argp2 ;
68228
68229   arg1 = (Dali::Toolkit::Control *)jarg1;
68230   argp2 = (Dali::Image *)jarg2;
68231   if (!argp2) {
68232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68233     return ;
68234   }
68235   arg2 = *argp2;
68236   {
68237     try {
68238       (arg1)->SetBackgroundImage(arg2);
68239     } catch (std::out_of_range& e) {
68240       {
68241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68242       };
68243     } catch (std::exception& e) {
68244       {
68245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68246       };
68247     } catch (Dali::DaliException e) {
68248       {
68249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68250       };
68251     } catch (...) {
68252       {
68253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68254       };
68255     }
68256   }
68257
68258 }
68259
68260
68261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68262   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68263
68264   arg1 = (Dali::Toolkit::Control *)jarg1;
68265   {
68266     try {
68267       (arg1)->ClearBackground();
68268     } catch (std::out_of_range& e) {
68269       {
68270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68271       };
68272     } catch (std::exception& e) {
68273       {
68274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68275       };
68276     } catch (Dali::DaliException e) {
68277       {
68278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68279       };
68280     } catch (...) {
68281       {
68282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68283       };
68284     }
68285   }
68286
68287 }
68288
68289
68290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68291   void * jresult ;
68292   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68293   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68294
68295   arg1 = (Dali::Toolkit::Control *)jarg1;
68296   {
68297     try {
68298       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68299     } catch (std::out_of_range& e) {
68300       {
68301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68302       };
68303     } catch (std::exception& e) {
68304       {
68305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68306       };
68307     } catch (Dali::DaliException e) {
68308       {
68309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68310       };
68311     } catch (...) {
68312       {
68313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68314       };
68315     }
68316   }
68317
68318   jresult = (void *)result;
68319   return jresult;
68320 }
68321
68322
68323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68324   void * jresult ;
68325   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68326   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68327
68328   arg1 = (Dali::Toolkit::Control *)jarg1;
68329   {
68330     try {
68331       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68332     } catch (std::out_of_range& e) {
68333       {
68334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68335       };
68336     } catch (std::exception& e) {
68337       {
68338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68339       };
68340     } catch (Dali::DaliException e) {
68341       {
68342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68343       };
68344     } catch (...) {
68345       {
68346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68347       };
68348     }
68349   }
68350
68351   jresult = (void *)result;
68352   return jresult;
68353 }
68354
68355
68356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68357   void * jresult ;
68358   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68359   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68360
68361   arg1 = (Dali::Toolkit::Control *)jarg1;
68362   {
68363     try {
68364       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68365     } catch (std::out_of_range& e) {
68366       {
68367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68368       };
68369     } catch (std::exception& e) {
68370       {
68371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68372       };
68373     } catch (Dali::DaliException e) {
68374       {
68375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68376       };
68377     } catch (...) {
68378       {
68379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68380       };
68381     }
68382   }
68383
68384   jresult = (void *)result;
68385   return jresult;
68386 }
68387
68388
68389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68390   void * jresult ;
68391   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68392   Dali::Toolkit::Control *result = 0 ;
68393
68394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68395   if (!arg1) {
68396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68397     return 0;
68398   }
68399   {
68400     try {
68401       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68402     } catch (std::out_of_range& e) {
68403       {
68404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68405       };
68406     } catch (std::exception& e) {
68407       {
68408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68409       };
68410     } catch (Dali::DaliException e) {
68411       {
68412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68413       };
68414     } catch (...) {
68415       {
68416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68417       };
68418     }
68419   }
68420
68421   jresult = (void *)result;
68422   return jresult;
68423 }
68424
68425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68426 {
68427   int jresult;
68428   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68429   arg1 = (Dali::Toolkit::Control *)jarg1;
68430
68431   if (!arg1) {
68432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68433     return 0;
68434   }
68435
68436   Dali::Property::Index arg2 = 0 ;
68437   arg2 = (Dali::Property::Index)jarg2;
68438
68439   Toolkit::Visual::ResourceStatus result;
68440   {
68441     try {
68442       result = arg1->GetVisualResourceStatus(arg2);
68443     } catch (std::out_of_range& e) {
68444       {
68445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68446       };
68447     } catch (std::exception& e) {
68448       {
68449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68450       };
68451     } catch (...) {
68452       {
68453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68454       };
68455     }
68456   }
68457   jresult = (int)(result);
68458   return jresult;
68459 }
68460
68461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68462 {
68463   void * jresult;
68464   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68465   arg1 = (Dali::Toolkit::Control *)jarg1;
68466
68467   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68468
68469   Dali::Toolkit::TransitionData *arg2 = 0 ;
68470   Dali::Animation result;
68471
68472   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68473   if (!arg2) {
68474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68475     return 0;
68476   }
68477   {
68478     try {
68479       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68480     } catch (std::out_of_range& e) {
68481       {
68482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68483       };
68484     } catch (std::exception& e) {
68485       {
68486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68487       };
68488     } catch (Dali::DaliException e) {
68489       {
68490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68491       };
68492     } catch (...) {
68493       {
68494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68495       };
68496     }
68497   }
68498
68499   jresult = new Dali::Animation((const Dali::Animation &)result);
68500   return jresult;
68501 }
68502
68503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68504 {
68505   Dali::Toolkit::Control arg1;
68506   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68507
68508   if (!argp1) {
68509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68510   }
68511   arg1 = *argp1;
68512
68513   Dali::Property::Index arg2 = 0 ;
68514   arg2 = (Dali::Property::Index)jarg2;
68515
68516   Dali::Property::Index arg3 = 0 ;
68517   arg3 = (Dali::Property::Index)jarg3;
68518
68519   Dali::Property::Value arg4;
68520   arg4 = (Dali::Property::Value *)jarg4;
68521
68522   {
68523     try {
68524       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68525     } catch (std::out_of_range& e) {
68526       {
68527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68528       };
68529     } catch (std::exception& e) {
68530       {
68531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68532       };
68533     } catch (...) {
68534       {
68535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68536       };
68537     }
68538   }
68539
68540
68541 }
68542
68543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68544   void * jresult ;
68545   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68546   Dali::Toolkit::LayoutItem result;
68547
68548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68549   if (!arg1) {
68550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68551     return 0;
68552   }
68553   {
68554     try {
68555       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68556     } catch (std::out_of_range& e) {
68557       {
68558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68559       };
68560     } catch (std::exception& e) {
68561       {
68562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68563       };
68564     } catch (...) {
68565       {
68566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68567       };
68568     }
68569   }
68570   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68571   return jresult;
68572 }
68573
68574
68575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68576   void * jresult ;
68577   Dali::Toolkit::Control arg1 ;
68578   Dali::Toolkit::Control *argp1 ;
68579   Dali::Toolkit::LayoutItem result;
68580
68581   argp1 = (Dali::Toolkit::Control *)jarg1;
68582   if (!argp1) {
68583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68584     return 0;
68585   }
68586   arg1 = *argp1;
68587   {
68588     try {
68589       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68590     } catch (std::out_of_range& e) {
68591       {
68592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68593       };
68594     } catch (std::exception& e) {
68595       {
68596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68597       };
68598     } catch (...) {
68599       {
68600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68601       };
68602     }
68603   }
68604   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68605   return jresult;
68606 }
68607
68608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68609   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68610   Dali::Toolkit::LayoutItem arg2 ;
68611   Dali::Toolkit::LayoutItem *argp2 ;
68612
68613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68614   if (!arg1) {
68615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68616     return ;
68617   }
68618   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68619   if (!argp2) {
68620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68621     return ;
68622   }
68623   arg2 = *argp2;
68624   {
68625     try {
68626       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68627     } catch (std::out_of_range& e) {
68628       {
68629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68630       };
68631     } catch (std::exception& e) {
68632       {
68633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68634       };
68635     } catch (...) {
68636       {
68637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68638       };
68639     }
68640   }
68641 }
68642
68643
68644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68645   Dali::Toolkit::Control arg1 ;
68646   Dali::Toolkit::LayoutItem arg2 ;
68647   Dali::Toolkit::Control *argp1 ;
68648   Dali::Toolkit::LayoutItem *argp2 ;
68649
68650   argp1 = (Dali::Toolkit::Control *)jarg1;
68651   if (!argp1) {
68652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68653     return ;
68654   }
68655   arg1 = *argp1;
68656   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68657   if (!argp2) {
68658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68659     return ;
68660   }
68661   arg2 = *argp2;
68662   {
68663     try {
68664       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68665     } catch (std::out_of_range& e) {
68666       {
68667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68668       };
68669     } catch (std::exception& e) {
68670       {
68671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68672       };
68673     } catch (...) {
68674       {
68675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68676       };
68677     }
68678   }
68679 }
68680
68681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayoutingRequired(void * jarg1, bool jarg2) {
68682   Dali::Toolkit::Control *arg1 = 0 ;
68683
68684   arg1 = (Dali::Toolkit::Control *)jarg1;
68685   if (!arg1) {
68686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68687     return ;
68688   }
68689
68690   {
68691     try {
68692       Dali::Toolkit::DevelControl::SetLayoutingRequired(*arg1,jarg2);
68693     } catch (std::out_of_range& e) {
68694       {
68695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68696       };
68697     } catch (std::exception& e) {
68698       {
68699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68700       };
68701     } catch (...) {
68702       {
68703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68704       };
68705     }
68706   }
68707 }
68708
68709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_IsLayoutingRequired(void * jarg1) {
68710   unsigned int jresult ;
68711   Dali::Toolkit::Control *arg1 = 0 ;
68712   bool result;
68713
68714   arg1 = (Dali::Toolkit::Control *)jarg1;
68715   if (!arg1) {
68716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68717     return 0;
68718   }
68719   {
68720     try {
68721       result = (bool)DevelControl::IsLayoutingRequired( *arg1 );
68722     } catch (std::out_of_range& e) {
68723       {
68724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68725       };
68726     } catch (std::exception& e) {
68727       {
68728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68729       };
68730     } catch (Dali::DaliException e) {
68731       {
68732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68733       };
68734     } catch (...) {
68735       {
68736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68737       };
68738     }
68739   }
68740
68741   jresult = result;
68742   return jresult;
68743 }
68744
68745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68746   void * jresult ;
68747   Dali::Toolkit::Control *arg1 = 0 ;
68748   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68749
68750   arg1 = (Dali::Toolkit::Control *)jarg1;
68751   if (!arg1) {
68752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68753     return 0;
68754   }
68755   {
68756     try {
68757       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68758     } catch (std::out_of_range& e) {
68759       {
68760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68761       };
68762     } catch (std::exception& e) {
68763       {
68764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68765       };
68766     } catch (Dali::DaliException e) {
68767       {
68768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68769       };
68770     } catch (...) {
68771       {
68772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68773       };
68774     }
68775   }
68776
68777   jresult = (void *)result;
68778   return jresult;
68779 }
68780
68781
68782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68783   unsigned int jresult ;
68784   Dali::Toolkit::Control *arg1 = 0 ;
68785   bool result;
68786
68787   arg1 = (Dali::Toolkit::Control *)jarg1;
68788   if (!arg1) {
68789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68790     return 0;
68791   }
68792   {
68793     try {
68794       result = (bool)arg1->IsResourceReady();
68795     } catch (std::out_of_range& e) {
68796       {
68797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68798       };
68799     } catch (std::exception& e) {
68800       {
68801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68802       };
68803     } catch (Dali::DaliException e) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68806       };
68807     } catch (...) {
68808       {
68809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68810       };
68811     }
68812   }
68813
68814   jresult = result;
68815   return jresult;
68816 }
68817
68818
68819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68820   void * jresult ;
68821   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68822
68823   {
68824     try {
68825       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68826     } catch (std::out_of_range& e) {
68827       {
68828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68829       };
68830     } catch (std::exception& e) {
68831       {
68832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68833       };
68834     } catch (Dali::DaliException e) {
68835       {
68836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68837       };
68838     } catch (...) {
68839       {
68840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68841       };
68842     }
68843   }
68844
68845   jresult = (void *)result;
68846   return jresult;
68847 }
68848
68849
68850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68851   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68852
68853   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68854   {
68855     try {
68856       delete arg1;
68857     } catch (std::out_of_range& e) {
68858       {
68859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68860       };
68861     } catch (std::exception& e) {
68862       {
68863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68864       };
68865     } catch (Dali::DaliException e) {
68866       {
68867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68868       };
68869     } catch (...) {
68870       {
68871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68872       };
68873     }
68874   }
68875
68876 }
68877
68878
68879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68880   void * jresult ;
68881   Dali::Toolkit::KeyInputFocusManager result;
68882
68883   {
68884     try {
68885       result = Dali::Toolkit::KeyInputFocusManager::Get();
68886     } catch (std::out_of_range& e) {
68887       {
68888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68889       };
68890     } catch (std::exception& e) {
68891       {
68892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68893       };
68894     } catch (Dali::DaliException e) {
68895       {
68896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68897       };
68898     } catch (...) {
68899       {
68900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68901       };
68902     }
68903   }
68904
68905   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68906   return jresult;
68907 }
68908
68909
68910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68911   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68912   Dali::Toolkit::Control arg2 ;
68913   Dali::Toolkit::Control *argp2 ;
68914
68915   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68916   argp2 = (Dali::Toolkit::Control *)jarg2;
68917   if (!argp2) {
68918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68919     return ;
68920   }
68921   arg2 = *argp2;
68922   {
68923     try {
68924       (arg1)->SetFocus(arg2);
68925     } catch (std::out_of_range& e) {
68926       {
68927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68928       };
68929     } catch (std::exception& e) {
68930       {
68931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68932       };
68933     } catch (Dali::DaliException e) {
68934       {
68935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68936       };
68937     } catch (...) {
68938       {
68939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68940       };
68941     }
68942   }
68943
68944 }
68945
68946
68947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68948   void * jresult ;
68949   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68950   Dali::Toolkit::Control result;
68951
68952   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68953   {
68954     try {
68955       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68956     } catch (std::out_of_range& e) {
68957       {
68958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68959       };
68960     } catch (std::exception& e) {
68961       {
68962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68963       };
68964     } catch (Dali::DaliException e) {
68965       {
68966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68967       };
68968     } catch (...) {
68969       {
68970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68971       };
68972     }
68973   }
68974
68975   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68976   return jresult;
68977 }
68978
68979
68980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68981   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68982   Dali::Toolkit::Control arg2 ;
68983   Dali::Toolkit::Control *argp2 ;
68984
68985   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68986   argp2 = (Dali::Toolkit::Control *)jarg2;
68987   if (!argp2) {
68988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68989     return ;
68990   }
68991   arg2 = *argp2;
68992   {
68993     try {
68994       (arg1)->RemoveFocus(arg2);
68995     } catch (std::out_of_range& e) {
68996       {
68997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68998       };
68999     } catch (std::exception& e) {
69000       {
69001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69002       };
69003     } catch (Dali::DaliException e) {
69004       {
69005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69006       };
69007     } catch (...) {
69008       {
69009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69010       };
69011     }
69012   }
69013
69014 }
69015
69016
69017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
69018   void * jresult ;
69019   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69020   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
69021
69022   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69023   {
69024     try {
69025       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
69026     } catch (std::out_of_range& e) {
69027       {
69028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69029       };
69030     } catch (std::exception& e) {
69031       {
69032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69033       };
69034     } catch (Dali::DaliException e) {
69035       {
69036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69037       };
69038     } catch (...) {
69039       {
69040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69041       };
69042     }
69043   }
69044
69045   jresult = (void *)result;
69046   return jresult;
69047 }
69048
69049
69050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
69051   void * jresult ;
69052   Dali::Toolkit::Alignment::Padding *result = 0 ;
69053
69054   {
69055     try {
69056       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
69057     } catch (std::out_of_range& e) {
69058       {
69059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69060       };
69061     } catch (std::exception& e) {
69062       {
69063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69064       };
69065     } catch (Dali::DaliException e) {
69066       {
69067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69068       };
69069     } catch (...) {
69070       {
69071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69072       };
69073     }
69074   }
69075
69076   jresult = (void *)result;
69077   return jresult;
69078 }
69079
69080
69081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69082   void * jresult ;
69083   float arg1 ;
69084   float arg2 ;
69085   float arg3 ;
69086   float arg4 ;
69087   Dali::Toolkit::Alignment::Padding *result = 0 ;
69088
69089   arg1 = (float)jarg1;
69090   arg2 = (float)jarg2;
69091   arg3 = (float)jarg3;
69092   arg4 = (float)jarg4;
69093   {
69094     try {
69095       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69096     } catch (std::out_of_range& e) {
69097       {
69098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69099       };
69100     } catch (std::exception& e) {
69101       {
69102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69103       };
69104     } catch (Dali::DaliException e) {
69105       {
69106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69107       };
69108     } catch (...) {
69109       {
69110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69111       };
69112     }
69113   }
69114
69115   jresult = (void *)result;
69116   return jresult;
69117 }
69118
69119
69120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69121   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69122   float arg2 ;
69123
69124   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69125   arg2 = (float)jarg2;
69126   if (arg1) (arg1)->left = arg2;
69127 }
69128
69129
69130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69131   float jresult ;
69132   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69133   float result;
69134
69135   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69136   result = (float) ((arg1)->left);
69137   jresult = result;
69138   return jresult;
69139 }
69140
69141
69142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69143   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69144   float arg2 ;
69145
69146   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69147   arg2 = (float)jarg2;
69148   if (arg1) (arg1)->right = arg2;
69149 }
69150
69151
69152 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69153   float jresult ;
69154   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69155   float result;
69156
69157   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69158   result = (float) ((arg1)->right);
69159   jresult = result;
69160   return jresult;
69161 }
69162
69163
69164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69165   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69166   float arg2 ;
69167
69168   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69169   arg2 = (float)jarg2;
69170   if (arg1) (arg1)->top = arg2;
69171 }
69172
69173
69174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69175   float jresult ;
69176   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69177   float result;
69178
69179   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69180   result = (float) ((arg1)->top);
69181   jresult = result;
69182   return jresult;
69183 }
69184
69185
69186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69187   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69188   float arg2 ;
69189
69190   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69191   arg2 = (float)jarg2;
69192   if (arg1) (arg1)->bottom = arg2;
69193 }
69194
69195
69196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69197   float jresult ;
69198   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69199   float result;
69200
69201   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69202   result = (float) ((arg1)->bottom);
69203   jresult = result;
69204   return jresult;
69205 }
69206
69207
69208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69209   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69210
69211   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69212   {
69213     try {
69214       delete arg1;
69215     } catch (std::out_of_range& e) {
69216       {
69217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69218       };
69219     } catch (std::exception& e) {
69220       {
69221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69222       };
69223     } catch (Dali::DaliException e) {
69224       {
69225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69226       };
69227     } catch (...) {
69228       {
69229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69230       };
69231     }
69232   }
69233
69234 }
69235
69236
69237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69238   void * jresult ;
69239   Dali::Toolkit::Alignment *result = 0 ;
69240
69241   {
69242     try {
69243       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69244     } catch (std::out_of_range& e) {
69245       {
69246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69247       };
69248     } catch (std::exception& e) {
69249       {
69250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69251       };
69252     } catch (Dali::DaliException e) {
69253       {
69254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69255       };
69256     } catch (...) {
69257       {
69258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69259       };
69260     }
69261   }
69262
69263   jresult = (void *)result;
69264   return jresult;
69265 }
69266
69267
69268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69269   void * jresult ;
69270   Dali::Toolkit::Alignment::Type arg1 ;
69271   Dali::Toolkit::Alignment::Type arg2 ;
69272   Dali::Toolkit::Alignment result;
69273
69274   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69275   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69276   {
69277     try {
69278       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69279     } catch (std::out_of_range& e) {
69280       {
69281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69282       };
69283     } catch (std::exception& e) {
69284       {
69285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69286       };
69287     } catch (Dali::DaliException e) {
69288       {
69289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69290       };
69291     } catch (...) {
69292       {
69293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69294       };
69295     }
69296   }
69297
69298   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69299   return jresult;
69300 }
69301
69302
69303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69304   void * jresult ;
69305   Dali::Toolkit::Alignment::Type arg1 ;
69306   Dali::Toolkit::Alignment result;
69307
69308   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69309   {
69310     try {
69311       result = Dali::Toolkit::Alignment::New(arg1);
69312     } catch (std::out_of_range& e) {
69313       {
69314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69315       };
69316     } catch (std::exception& e) {
69317       {
69318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69319       };
69320     } catch (Dali::DaliException e) {
69321       {
69322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69323       };
69324     } catch (...) {
69325       {
69326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69327       };
69328     }
69329   }
69330
69331   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69332   return jresult;
69333 }
69334
69335
69336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69337   void * jresult ;
69338   Dali::Toolkit::Alignment result;
69339
69340   {
69341     try {
69342       result = Dali::Toolkit::Alignment::New();
69343     } catch (std::out_of_range& e) {
69344       {
69345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69346       };
69347     } catch (std::exception& e) {
69348       {
69349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69350       };
69351     } catch (Dali::DaliException e) {
69352       {
69353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69354       };
69355     } catch (...) {
69356       {
69357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69358       };
69359     }
69360   }
69361
69362   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69363   return jresult;
69364 }
69365
69366
69367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69368   void * jresult ;
69369   Dali::Toolkit::Alignment *arg1 = 0 ;
69370   Dali::Toolkit::Alignment *result = 0 ;
69371
69372   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69373   if (!arg1) {
69374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69375     return 0;
69376   }
69377   {
69378     try {
69379       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69380     } catch (std::out_of_range& e) {
69381       {
69382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69383       };
69384     } catch (std::exception& e) {
69385       {
69386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69387       };
69388     } catch (Dali::DaliException e) {
69389       {
69390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69391       };
69392     } catch (...) {
69393       {
69394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69395       };
69396     }
69397   }
69398
69399   jresult = (void *)result;
69400   return jresult;
69401 }
69402
69403
69404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69405   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69406
69407   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69408   {
69409     try {
69410       delete arg1;
69411     } catch (std::out_of_range& e) {
69412       {
69413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69414       };
69415     } catch (std::exception& e) {
69416       {
69417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69418       };
69419     } catch (Dali::DaliException e) {
69420       {
69421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69422       };
69423     } catch (...) {
69424       {
69425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69426       };
69427     }
69428   }
69429
69430 }
69431
69432
69433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69434   void * jresult ;
69435   Dali::BaseHandle arg1 ;
69436   Dali::BaseHandle *argp1 ;
69437   Dali::Toolkit::Alignment result;
69438
69439   argp1 = (Dali::BaseHandle *)jarg1;
69440   if (!argp1) {
69441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69442     return 0;
69443   }
69444   arg1 = *argp1;
69445   {
69446     try {
69447       result = Dali::Toolkit::Alignment::DownCast(arg1);
69448     } catch (std::out_of_range& e) {
69449       {
69450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69451       };
69452     } catch (std::exception& e) {
69453       {
69454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69455       };
69456     } catch (Dali::DaliException e) {
69457       {
69458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69459       };
69460     } catch (...) {
69461       {
69462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69463       };
69464     }
69465   }
69466
69467   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69468   return jresult;
69469 }
69470
69471
69472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69473   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69474   Dali::Toolkit::Alignment::Type arg2 ;
69475
69476   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69477   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69478   {
69479     try {
69480       (arg1)->SetAlignmentType(arg2);
69481     } catch (std::out_of_range& e) {
69482       {
69483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69484       };
69485     } catch (std::exception& e) {
69486       {
69487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69488       };
69489     } catch (Dali::DaliException e) {
69490       {
69491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69492       };
69493     } catch (...) {
69494       {
69495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69496       };
69497     }
69498   }
69499
69500 }
69501
69502
69503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69504   int jresult ;
69505   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69506   Dali::Toolkit::Alignment::Type result;
69507
69508   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69509   {
69510     try {
69511       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69512     } catch (std::out_of_range& e) {
69513       {
69514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69515       };
69516     } catch (std::exception& e) {
69517       {
69518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69519       };
69520     } catch (Dali::DaliException e) {
69521       {
69522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69523       };
69524     } catch (...) {
69525       {
69526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69527       };
69528     }
69529   }
69530
69531   jresult = (int)result;
69532   return jresult;
69533 }
69534
69535
69536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69537   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69538   Dali::Toolkit::Alignment::Scaling arg2 ;
69539
69540   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69541   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69542   {
69543     try {
69544       (arg1)->SetScaling(arg2);
69545     } catch (std::out_of_range& e) {
69546       {
69547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69548       };
69549     } catch (std::exception& e) {
69550       {
69551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69552       };
69553     } catch (Dali::DaliException e) {
69554       {
69555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69556       };
69557     } catch (...) {
69558       {
69559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69560       };
69561     }
69562   }
69563
69564 }
69565
69566
69567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69568   int jresult ;
69569   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69570   Dali::Toolkit::Alignment::Scaling result;
69571
69572   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69573   {
69574     try {
69575       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69576     } catch (std::out_of_range& e) {
69577       {
69578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69579       };
69580     } catch (std::exception& e) {
69581       {
69582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69583       };
69584     } catch (Dali::DaliException e) {
69585       {
69586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69587       };
69588     } catch (...) {
69589       {
69590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69591       };
69592     }
69593   }
69594
69595   jresult = (int)result;
69596   return jresult;
69597 }
69598
69599
69600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69601   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69602   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69603
69604   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69605   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69606   if (!arg2) {
69607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69608     return ;
69609   }
69610   {
69611     try {
69612       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69613     } catch (std::out_of_range& e) {
69614       {
69615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69616       };
69617     } catch (std::exception& e) {
69618       {
69619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69620       };
69621     } catch (Dali::DaliException e) {
69622       {
69623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69624       };
69625     } catch (...) {
69626       {
69627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69628       };
69629     }
69630   }
69631
69632 }
69633
69634
69635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69636   void * jresult ;
69637   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69638   Dali::Toolkit::Alignment::Padding *result = 0 ;
69639
69640   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69641   {
69642     try {
69643       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69644     } catch (std::out_of_range& e) {
69645       {
69646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69647       };
69648     } catch (std::exception& e) {
69649       {
69650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69651       };
69652     } catch (Dali::DaliException e) {
69653       {
69654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69655       };
69656     } catch (...) {
69657       {
69658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69659       };
69660     }
69661   }
69662
69663   jresult = (void *)result;
69664   return jresult;
69665 }
69666
69667
69668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69669   void * jresult ;
69670   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69671   Dali::Toolkit::Alignment *arg2 = 0 ;
69672   Dali::Toolkit::Alignment *result = 0 ;
69673
69674   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69675   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69676   if (!arg2) {
69677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69678     return 0;
69679   }
69680   {
69681     try {
69682       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69683     } catch (std::out_of_range& e) {
69684       {
69685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69686       };
69687     } catch (std::exception& e) {
69688       {
69689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69690       };
69691     } catch (Dali::DaliException e) {
69692       {
69693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69694       };
69695     } catch (...) {
69696       {
69697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69698       };
69699     }
69700   }
69701
69702   jresult = (void *)result;
69703   return jresult;
69704 }
69705
69706
69707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69708   int jresult ;
69709   int result;
69710
69711   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69712   jresult = (int)result;
69713   return jresult;
69714 }
69715
69716
69717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69718   int jresult ;
69719   int result;
69720
69721   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69722   jresult = (int)result;
69723   return jresult;
69724 }
69725
69726
69727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69728   int jresult ;
69729   int result;
69730
69731   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69732   jresult = (int)result;
69733   return jresult;
69734 }
69735
69736
69737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69738   int jresult ;
69739   int result;
69740
69741   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69742   jresult = (int)result;
69743   return jresult;
69744 }
69745
69746
69747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69748   int jresult ;
69749   int result;
69750
69751   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69752   jresult = (int)result;
69753   return jresult;
69754 }
69755
69756
69757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69758   int jresult ;
69759   int result;
69760
69761   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69762   jresult = (int)result;
69763   return jresult;
69764 }
69765
69766
69767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69768   int jresult ;
69769   int result;
69770
69771   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69772   jresult = (int)result;
69773   return jresult;
69774 }
69775
69776
69777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69778   int jresult ;
69779   int result;
69780
69781   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69782   jresult = (int)result;
69783   return jresult;
69784 }
69785
69786
69787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69788   int jresult ;
69789   int result;
69790
69791   result = (int)Dali::Toolkit::Button::Property::LABEL;
69792   jresult = (int)result;
69793   return jresult;
69794 }
69795
69796
69797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69798   int jresult ;
69799   int result;
69800
69801   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69802   jresult = (int)result;
69803   return jresult;
69804 }
69805
69806
69807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69808   void * jresult ;
69809   Dali::Toolkit::Button::Property *result = 0 ;
69810
69811   {
69812     try {
69813       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69814     } catch (std::out_of_range& e) {
69815       {
69816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69817       };
69818     } catch (std::exception& e) {
69819       {
69820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69821       };
69822     } catch (Dali::DaliException e) {
69823       {
69824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69825       };
69826     } catch (...) {
69827       {
69828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69829       };
69830     }
69831   }
69832
69833   jresult = (void *)result;
69834   return jresult;
69835 }
69836
69837
69838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69839   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69840
69841   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69842   {
69843     try {
69844       delete arg1;
69845     } catch (std::out_of_range& e) {
69846       {
69847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69848       };
69849     } catch (std::exception& e) {
69850       {
69851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69852       };
69853     } catch (Dali::DaliException e) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69856       };
69857     } catch (...) {
69858       {
69859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69860       };
69861     }
69862   }
69863
69864 }
69865
69866
69867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69868   void * jresult ;
69869   Dali::Toolkit::Button *result = 0 ;
69870
69871   {
69872     try {
69873       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69874     } catch (std::out_of_range& e) {
69875       {
69876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69877       };
69878     } catch (std::exception& e) {
69879       {
69880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69881       };
69882     } catch (Dali::DaliException e) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69885       };
69886     } catch (...) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69889       };
69890     }
69891   }
69892
69893   jresult = (void *)result;
69894   return jresult;
69895 }
69896
69897
69898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69899   void * jresult ;
69900   Dali::Toolkit::Button *arg1 = 0 ;
69901   Dali::Toolkit::Button *result = 0 ;
69902
69903   arg1 = (Dali::Toolkit::Button *)jarg1;
69904   if (!arg1) {
69905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69906     return 0;
69907   }
69908   {
69909     try {
69910       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69911     } catch (std::out_of_range& e) {
69912       {
69913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69914       };
69915     } catch (std::exception& e) {
69916       {
69917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69918       };
69919     } catch (Dali::DaliException e) {
69920       {
69921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69922       };
69923     } catch (...) {
69924       {
69925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69926       };
69927     }
69928   }
69929
69930   jresult = (void *)result;
69931   return jresult;
69932 }
69933
69934
69935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69936   void * jresult ;
69937   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69938   Dali::Toolkit::Button *arg2 = 0 ;
69939   Dali::Toolkit::Button *result = 0 ;
69940
69941   arg1 = (Dali::Toolkit::Button *)jarg1;
69942   arg2 = (Dali::Toolkit::Button *)jarg2;
69943   if (!arg2) {
69944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69945     return 0;
69946   }
69947   {
69948     try {
69949       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69950     } catch (std::out_of_range& e) {
69951       {
69952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69953       };
69954     } catch (std::exception& e) {
69955       {
69956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69957       };
69958     } catch (Dali::DaliException e) {
69959       {
69960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69961       };
69962     } catch (...) {
69963       {
69964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69965       };
69966     }
69967   }
69968
69969   jresult = (void *)result;
69970   return jresult;
69971 }
69972
69973
69974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69975   void * jresult ;
69976   Dali::BaseHandle arg1 ;
69977   Dali::BaseHandle *argp1 ;
69978   Dali::Toolkit::Button result;
69979
69980   argp1 = (Dali::BaseHandle *)jarg1;
69981   if (!argp1) {
69982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69983     return 0;
69984   }
69985   arg1 = *argp1;
69986   {
69987     try {
69988       result = Dali::Toolkit::Button::DownCast(arg1);
69989     } catch (std::out_of_range& e) {
69990       {
69991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69992       };
69993     } catch (std::exception& e) {
69994       {
69995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69996       };
69997     } catch (Dali::DaliException e) {
69998       {
69999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70000       };
70001     } catch (...) {
70002       {
70003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70004       };
70005     }
70006   }
70007
70008   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
70009   return jresult;
70010 }
70011
70012
70013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
70014   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70015
70016   arg1 = (Dali::Toolkit::Button *)jarg1;
70017   {
70018     try {
70019       delete arg1;
70020     } catch (std::out_of_range& e) {
70021       {
70022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70023       };
70024     } catch (std::exception& e) {
70025       {
70026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70027       };
70028     } catch (Dali::DaliException e) {
70029       {
70030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70031       };
70032     } catch (...) {
70033       {
70034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70035       };
70036     }
70037   }
70038
70039 }
70040
70041
70042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
70043   unsigned int jresult ;
70044   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70045   bool result;
70046
70047   arg1 = (Dali::Toolkit::Button *)jarg1;
70048   {
70049     try {
70050       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
70051     } catch (std::out_of_range& e) {
70052       {
70053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70054       };
70055     } catch (std::exception& e) {
70056       {
70057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70058       };
70059     } catch (Dali::DaliException e) {
70060       {
70061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70062       };
70063     } catch (...) {
70064       {
70065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70066       };
70067     }
70068   }
70069
70070   jresult = result;
70071   return jresult;
70072 }
70073
70074
70075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70076   unsigned int jresult ;
70077   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70078   bool result;
70079
70080   arg1 = (Dali::Toolkit::Button *)jarg1;
70081   {
70082     try {
70083       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70084     } catch (std::out_of_range& e) {
70085       {
70086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70087       };
70088     } catch (std::exception& e) {
70089       {
70090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70091       };
70092     } catch (Dali::DaliException e) {
70093       {
70094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70095       };
70096     } catch (...) {
70097       {
70098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70099       };
70100     }
70101   }
70102
70103   jresult = result;
70104   return jresult;
70105 }
70106
70107
70108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70109   float jresult ;
70110   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70111   float result;
70112
70113   arg1 = (Dali::Toolkit::Button *)jarg1;
70114   {
70115     try {
70116       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70117     } catch (std::out_of_range& e) {
70118       {
70119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70120       };
70121     } catch (std::exception& e) {
70122       {
70123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70124       };
70125     } catch (Dali::DaliException e) {
70126       {
70127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70128       };
70129     } catch (...) {
70130       {
70131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70132       };
70133     }
70134   }
70135
70136   jresult = result;
70137   return jresult;
70138 }
70139
70140
70141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70142   float jresult ;
70143   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70144   float result;
70145
70146   arg1 = (Dali::Toolkit::Button *)jarg1;
70147   {
70148     try {
70149       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70150     } catch (std::out_of_range& e) {
70151       {
70152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70153       };
70154     } catch (std::exception& e) {
70155       {
70156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70157       };
70158     } catch (Dali::DaliException e) {
70159       {
70160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70161       };
70162     } catch (...) {
70163       {
70164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70165       };
70166     }
70167   }
70168
70169   jresult = result;
70170   return jresult;
70171 }
70172
70173
70174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70175   unsigned int jresult ;
70176   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70177   bool result;
70178
70179   arg1 = (Dali::Toolkit::Button *)jarg1;
70180   {
70181     try {
70182       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70183     } catch (std::out_of_range& e) {
70184       {
70185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70186       };
70187     } catch (std::exception& e) {
70188       {
70189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70190       };
70191     } catch (Dali::DaliException e) {
70192       {
70193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70194       };
70195     } catch (...) {
70196       {
70197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70198       };
70199     }
70200   }
70201
70202   jresult = result;
70203   return jresult;
70204 }
70205
70206
70207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70208   unsigned int jresult ;
70209   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70210   bool result;
70211
70212   arg1 = (Dali::Toolkit::Button *)jarg1;
70213   {
70214     try {
70215       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70216     } catch (std::out_of_range& e) {
70217       {
70218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70219       };
70220     } catch (std::exception& e) {
70221       {
70222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70223       };
70224     } catch (Dali::DaliException e) {
70225       {
70226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70227       };
70228     } catch (...) {
70229       {
70230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70231       };
70232     }
70233   }
70234
70235   jresult = result;
70236   return jresult;
70237 }
70238
70239
70240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70241   float jresult ;
70242   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70243   float result;
70244
70245   arg1 = (Dali::Toolkit::Button *)jarg1;
70246   {
70247     try {
70248       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70249     } catch (std::out_of_range& e) {
70250       {
70251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70252       };
70253     } catch (std::exception& e) {
70254       {
70255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70256       };
70257     } catch (Dali::DaliException e) {
70258       {
70259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70260       };
70261     } catch (...) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70264       };
70265     }
70266   }
70267
70268   jresult = result;
70269   return jresult;
70270 }
70271
70272
70273 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70274   char * jresult ;
70275   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70276   std::string result;
70277
70278   arg1 = (Dali::Toolkit::Button *)jarg1;
70279   {
70280     try {
70281       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70282     } catch (std::out_of_range& e) {
70283       {
70284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70285       };
70286     } catch (std::exception& e) {
70287       {
70288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70289       };
70290     } catch (Dali::DaliException e) {
70291       {
70292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70293       };
70294     } catch (...) {
70295       {
70296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70297       };
70298     }
70299   }
70300
70301   jresult = SWIG_csharp_string_callback((&result)->c_str());
70302   return jresult;
70303 }
70304
70305
70306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70307   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70308   Dali::Actor arg2 ;
70309   Dali::Actor *argp2 ;
70310
70311   arg1 = (Dali::Toolkit::Button *)jarg1;
70312   argp2 = (Dali::Actor *)jarg2;
70313   if (!argp2) {
70314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70315     return ;
70316   }
70317   arg2 = *argp2;
70318   {
70319     try {
70320       (arg1)->SetLabel(arg2);
70321     } catch (std::out_of_range& e) {
70322       {
70323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70324       };
70325     } catch (std::exception& e) {
70326       {
70327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70328       };
70329     } catch (Dali::DaliException e) {
70330       {
70331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70332       };
70333     } catch (...) {
70334       {
70335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70336       };
70337     }
70338   }
70339
70340 }
70341
70342
70343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70344   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70345   Dali::Image arg2 ;
70346   Dali::Image *argp2 ;
70347
70348   arg1 = (Dali::Toolkit::Button *)jarg1;
70349   argp2 = (Dali::Image *)jarg2;
70350   if (!argp2) {
70351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70352     return ;
70353   }
70354   arg2 = *argp2;
70355   {
70356     try {
70357       (arg1)->SetButtonImage(arg2);
70358     } catch (std::out_of_range& e) {
70359       {
70360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70361       };
70362     } catch (std::exception& e) {
70363       {
70364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70365       };
70366     } catch (Dali::DaliException e) {
70367       {
70368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70369       };
70370     } catch (...) {
70371       {
70372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70373       };
70374     }
70375   }
70376
70377 }
70378
70379
70380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70381   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70382   Dali::Image arg2 ;
70383   Dali::Image *argp2 ;
70384
70385   arg1 = (Dali::Toolkit::Button *)jarg1;
70386   argp2 = (Dali::Image *)jarg2;
70387   if (!argp2) {
70388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70389     return ;
70390   }
70391   arg2 = *argp2;
70392   {
70393     try {
70394       (arg1)->SetSelectedImage(arg2);
70395     } catch (std::out_of_range& e) {
70396       {
70397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70398       };
70399     } catch (std::exception& e) {
70400       {
70401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70402       };
70403     } catch (Dali::DaliException e) {
70404       {
70405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70406       };
70407     } catch (...) {
70408       {
70409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70410       };
70411     }
70412   }
70413
70414 }
70415
70416
70417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70418   void * jresult ;
70419   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70420   Dali::Actor result;
70421
70422   arg1 = (Dali::Toolkit::Button *)jarg1;
70423   {
70424     try {
70425       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70426     } catch (std::out_of_range& e) {
70427       {
70428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70429       };
70430     } catch (std::exception& e) {
70431       {
70432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70433       };
70434     } catch (Dali::DaliException e) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70437       };
70438     } catch (...) {
70439       {
70440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70441       };
70442     }
70443   }
70444
70445   jresult = new Dali::Actor((const Dali::Actor &)result);
70446   return jresult;
70447 }
70448
70449
70450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70451   void * jresult ;
70452   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70453   Dali::Actor result;
70454
70455   arg1 = (Dali::Toolkit::Button *)jarg1;
70456   {
70457     try {
70458       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70459     } catch (std::out_of_range& e) {
70460       {
70461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70462       };
70463     } catch (std::exception& e) {
70464       {
70465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70466       };
70467     } catch (Dali::DaliException e) {
70468       {
70469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70470       };
70471     } catch (...) {
70472       {
70473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70474       };
70475     }
70476   }
70477
70478   jresult = new Dali::Actor((const Dali::Actor &)result);
70479   return jresult;
70480 }
70481
70482
70483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70484   void * jresult ;
70485   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70486   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70487
70488   arg1 = (Dali::Toolkit::Button *)jarg1;
70489   {
70490     try {
70491       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70492     } catch (std::out_of_range& e) {
70493       {
70494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70495       };
70496     } catch (std::exception& e) {
70497       {
70498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70499       };
70500     } catch (Dali::DaliException e) {
70501       {
70502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70503       };
70504     } catch (...) {
70505       {
70506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70507       };
70508     }
70509   }
70510
70511   jresult = (void *)result;
70512   return jresult;
70513 }
70514
70515
70516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70517   void * jresult ;
70518   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70519   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70520
70521   arg1 = (Dali::Toolkit::Button *)jarg1;
70522   {
70523     try {
70524       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70525     } catch (std::out_of_range& e) {
70526       {
70527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70528       };
70529     } catch (std::exception& e) {
70530       {
70531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70532       };
70533     } catch (Dali::DaliException e) {
70534       {
70535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70536       };
70537     } catch (...) {
70538       {
70539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70540       };
70541     }
70542   }
70543
70544   jresult = (void *)result;
70545   return jresult;
70546 }
70547
70548
70549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70550   void * jresult ;
70551   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70552   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70553
70554   arg1 = (Dali::Toolkit::Button *)jarg1;
70555   {
70556     try {
70557       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70558     } catch (std::out_of_range& e) {
70559       {
70560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70561       };
70562     } catch (std::exception& e) {
70563       {
70564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70565       };
70566     } catch (Dali::DaliException e) {
70567       {
70568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70569       };
70570     } catch (...) {
70571       {
70572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70573       };
70574     }
70575   }
70576
70577   jresult = (void *)result;
70578   return jresult;
70579 }
70580
70581
70582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70583   void * jresult ;
70584   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70585   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70586
70587   arg1 = (Dali::Toolkit::Button *)jarg1;
70588   {
70589     try {
70590       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70591     } catch (std::out_of_range& e) {
70592       {
70593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70594       };
70595     } catch (std::exception& e) {
70596       {
70597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70598       };
70599     } catch (Dali::DaliException e) {
70600       {
70601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70602       };
70603     } catch (...) {
70604       {
70605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70606       };
70607     }
70608   }
70609
70610   jresult = (void *)result;
70611   return jresult;
70612 }
70613
70614
70615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70616   void * jresult ;
70617   Dali::Toolkit::CheckBoxButton *result = 0 ;
70618
70619   {
70620     try {
70621       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70622     } catch (std::out_of_range& e) {
70623       {
70624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70625       };
70626     } catch (std::exception& e) {
70627       {
70628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70629       };
70630     } catch (Dali::DaliException e) {
70631       {
70632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70633       };
70634     } catch (...) {
70635       {
70636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70637       };
70638     }
70639   }
70640
70641   jresult = (void *)result;
70642   return jresult;
70643 }
70644
70645
70646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70647   void * jresult ;
70648   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70649   Dali::Toolkit::CheckBoxButton *result = 0 ;
70650
70651   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70652   if (!arg1) {
70653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70654     return 0;
70655   }
70656   {
70657     try {
70658       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70659     } catch (std::out_of_range& e) {
70660       {
70661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70662       };
70663     } catch (std::exception& e) {
70664       {
70665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70666       };
70667     } catch (Dali::DaliException e) {
70668       {
70669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70670       };
70671     } catch (...) {
70672       {
70673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70674       };
70675     }
70676   }
70677
70678   jresult = (void *)result;
70679   return jresult;
70680 }
70681
70682
70683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70684   void * jresult ;
70685   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70686   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70687   Dali::Toolkit::CheckBoxButton *result = 0 ;
70688
70689   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70690   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70691   if (!arg2) {
70692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70693     return 0;
70694   }
70695   {
70696     try {
70697       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70698     } catch (std::out_of_range& e) {
70699       {
70700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70701       };
70702     } catch (std::exception& e) {
70703       {
70704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70705       };
70706     } catch (Dali::DaliException e) {
70707       {
70708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70709       };
70710     } catch (...) {
70711       {
70712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70713       };
70714     }
70715   }
70716
70717   jresult = (void *)result;
70718   return jresult;
70719 }
70720
70721
70722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70723   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70724
70725   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70726   {
70727     try {
70728       delete arg1;
70729     } catch (std::out_of_range& e) {
70730       {
70731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70732       };
70733     } catch (std::exception& e) {
70734       {
70735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70736       };
70737     } catch (Dali::DaliException e) {
70738       {
70739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70740       };
70741     } catch (...) {
70742       {
70743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70744       };
70745     }
70746   }
70747
70748 }
70749
70750
70751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70752   void * jresult ;
70753   Dali::Toolkit::CheckBoxButton result;
70754
70755   {
70756     try {
70757       result = Dali::Toolkit::CheckBoxButton::New();
70758     } catch (std::out_of_range& e) {
70759       {
70760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70761       };
70762     } catch (std::exception& e) {
70763       {
70764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70765       };
70766     } catch (Dali::DaliException e) {
70767       {
70768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70769       };
70770     } catch (...) {
70771       {
70772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70773       };
70774     }
70775   }
70776
70777   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70778   return jresult;
70779 }
70780
70781
70782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70783   void * jresult ;
70784   Dali::BaseHandle arg1 ;
70785   Dali::BaseHandle *argp1 ;
70786   Dali::Toolkit::CheckBoxButton result;
70787
70788   argp1 = (Dali::BaseHandle *)jarg1;
70789   if (!argp1) {
70790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70791     return 0;
70792   }
70793   arg1 = *argp1;
70794   {
70795     try {
70796       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70797     } catch (std::out_of_range& e) {
70798       {
70799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70800       };
70801     } catch (std::exception& e) {
70802       {
70803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70804       };
70805     } catch (Dali::DaliException e) {
70806       {
70807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70808       };
70809     } catch (...) {
70810       {
70811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70812       };
70813     }
70814   }
70815
70816   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70817   return jresult;
70818 }
70819
70820
70821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70822   int jresult ;
70823   int result;
70824
70825   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70826   jresult = (int)result;
70827   return jresult;
70828 }
70829
70830
70831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70832   int jresult ;
70833   int result;
70834
70835   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70836   jresult = (int)result;
70837   return jresult;
70838 }
70839
70840
70841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70842   int jresult ;
70843   int result;
70844
70845   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70846   jresult = (int)result;
70847   return jresult;
70848 }
70849
70850
70851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70852   int jresult ;
70853   int result;
70854
70855   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70856   jresult = (int)result;
70857   return jresult;
70858 }
70859
70860
70861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70862   int jresult ;
70863   int result;
70864
70865   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70866   jresult = (int)result;
70867   return jresult;
70868 }
70869
70870
70871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70872   void * jresult ;
70873   Dali::Toolkit::PushButton::Property *result = 0 ;
70874
70875   {
70876     try {
70877       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70878     } catch (std::out_of_range& e) {
70879       {
70880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70881       };
70882     } catch (std::exception& e) {
70883       {
70884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70885       };
70886     } catch (Dali::DaliException e) {
70887       {
70888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70889       };
70890     } catch (...) {
70891       {
70892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70893       };
70894     }
70895   }
70896
70897   jresult = (void *)result;
70898   return jresult;
70899 }
70900
70901
70902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70903   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70904
70905   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70906   {
70907     try {
70908       delete arg1;
70909     } catch (std::out_of_range& e) {
70910       {
70911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70912       };
70913     } catch (std::exception& e) {
70914       {
70915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70916       };
70917     } catch (Dali::DaliException e) {
70918       {
70919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70920       };
70921     } catch (...) {
70922       {
70923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70924       };
70925     }
70926   }
70927
70928 }
70929
70930
70931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70932   void * jresult ;
70933   Dali::Toolkit::PushButton *result = 0 ;
70934
70935   {
70936     try {
70937       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70938     } catch (std::out_of_range& e) {
70939       {
70940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70941       };
70942     } catch (std::exception& e) {
70943       {
70944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70945       };
70946     } catch (Dali::DaliException e) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70949       };
70950     } catch (...) {
70951       {
70952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70953       };
70954     }
70955   }
70956
70957   jresult = (void *)result;
70958   return jresult;
70959 }
70960
70961
70962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70963   void * jresult ;
70964   Dali::Toolkit::PushButton *arg1 = 0 ;
70965   Dali::Toolkit::PushButton *result = 0 ;
70966
70967   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70968   if (!arg1) {
70969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70970     return 0;
70971   }
70972   {
70973     try {
70974       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70975     } catch (std::out_of_range& e) {
70976       {
70977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70978       };
70979     } catch (std::exception& e) {
70980       {
70981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70982       };
70983     } catch (Dali::DaliException e) {
70984       {
70985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70986       };
70987     } catch (...) {
70988       {
70989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70990       };
70991     }
70992   }
70993
70994   jresult = (void *)result;
70995   return jresult;
70996 }
70997
70998
70999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
71000   void * jresult ;
71001   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71002   Dali::Toolkit::PushButton *arg2 = 0 ;
71003   Dali::Toolkit::PushButton *result = 0 ;
71004
71005   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71006   arg2 = (Dali::Toolkit::PushButton *)jarg2;
71007   if (!arg2) {
71008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
71009     return 0;
71010   }
71011   {
71012     try {
71013       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
71014     } catch (std::out_of_range& e) {
71015       {
71016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71017       };
71018     } catch (std::exception& e) {
71019       {
71020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71021       };
71022     } catch (Dali::DaliException e) {
71023       {
71024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71025       };
71026     } catch (...) {
71027       {
71028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71029       };
71030     }
71031   }
71032
71033   jresult = (void *)result;
71034   return jresult;
71035 }
71036
71037
71038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
71039   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71040
71041   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71042   {
71043     try {
71044       delete arg1;
71045     } catch (std::out_of_range& e) {
71046       {
71047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71048       };
71049     } catch (std::exception& e) {
71050       {
71051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71052       };
71053     } catch (Dali::DaliException e) {
71054       {
71055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71056       };
71057     } catch (...) {
71058       {
71059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71060       };
71061     }
71062   }
71063
71064 }
71065
71066
71067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71068   void * jresult ;
71069   Dali::Toolkit::PushButton result;
71070
71071   {
71072     try {
71073       result = Dali::Toolkit::PushButton::New();
71074     } catch (std::out_of_range& e) {
71075       {
71076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71077       };
71078     } catch (std::exception& e) {
71079       {
71080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71081       };
71082     } catch (Dali::DaliException e) {
71083       {
71084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71085       };
71086     } catch (...) {
71087       {
71088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71089       };
71090     }
71091   }
71092
71093   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71094   return jresult;
71095 }
71096
71097
71098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71099   void * jresult ;
71100   Dali::BaseHandle arg1 ;
71101   Dali::BaseHandle *argp1 ;
71102   Dali::Toolkit::PushButton result;
71103
71104   argp1 = (Dali::BaseHandle *)jarg1;
71105   if (!argp1) {
71106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71107     return 0;
71108   }
71109   arg1 = *argp1;
71110   {
71111     try {
71112       result = Dali::Toolkit::PushButton::DownCast(arg1);
71113     } catch (std::out_of_range& e) {
71114       {
71115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71116       };
71117     } catch (std::exception& e) {
71118       {
71119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71120       };
71121     } catch (Dali::DaliException e) {
71122       {
71123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71124       };
71125     } catch (...) {
71126       {
71127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71128       };
71129     }
71130   }
71131
71132   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71133   return jresult;
71134 }
71135
71136
71137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71138   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71139   Dali::Image arg2 ;
71140   Dali::Image *argp2 ;
71141
71142   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71143   argp2 = (Dali::Image *)jarg2;
71144   if (!argp2) {
71145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71146     return ;
71147   }
71148   arg2 = *argp2;
71149   {
71150     try {
71151       (arg1)->SetButtonImage(arg2);
71152     } catch (std::out_of_range& e) {
71153       {
71154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71155       };
71156     } catch (std::exception& e) {
71157       {
71158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71159       };
71160     } catch (Dali::DaliException e) {
71161       {
71162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71163       };
71164     } catch (...) {
71165       {
71166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71167       };
71168     }
71169   }
71170
71171 }
71172
71173
71174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71175   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71176   Dali::Actor arg2 ;
71177   Dali::Actor *argp2 ;
71178
71179   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71180   argp2 = (Dali::Actor *)jarg2;
71181   if (!argp2) {
71182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71183     return ;
71184   }
71185   arg2 = *argp2;
71186   {
71187     try {
71188       (arg1)->SetButtonImage(arg2);
71189     } catch (std::out_of_range& e) {
71190       {
71191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71192       };
71193     } catch (std::exception& e) {
71194       {
71195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71196       };
71197     } catch (Dali::DaliException e) {
71198       {
71199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71200       };
71201     } catch (...) {
71202       {
71203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71204       };
71205     }
71206   }
71207
71208 }
71209
71210
71211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71212   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71213   Dali::Actor arg2 ;
71214   Dali::Actor *argp2 ;
71215
71216   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71217   argp2 = (Dali::Actor *)jarg2;
71218   if (!argp2) {
71219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71220     return ;
71221   }
71222   arg2 = *argp2;
71223   {
71224     try {
71225       (arg1)->SetBackgroundImage(arg2);
71226     } catch (std::out_of_range& e) {
71227       {
71228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71229       };
71230     } catch (std::exception& e) {
71231       {
71232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71233       };
71234     } catch (Dali::DaliException e) {
71235       {
71236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71237       };
71238     } catch (...) {
71239       {
71240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71241       };
71242     }
71243   }
71244
71245 }
71246
71247
71248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71249   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71250   Dali::Image arg2 ;
71251   Dali::Image *argp2 ;
71252
71253   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71254   argp2 = (Dali::Image *)jarg2;
71255   if (!argp2) {
71256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71257     return ;
71258   }
71259   arg2 = *argp2;
71260   {
71261     try {
71262       (arg1)->SetSelectedImage(arg2);
71263     } catch (std::out_of_range& e) {
71264       {
71265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71266       };
71267     } catch (std::exception& e) {
71268       {
71269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71270       };
71271     } catch (Dali::DaliException e) {
71272       {
71273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71274       };
71275     } catch (...) {
71276       {
71277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71278       };
71279     }
71280   }
71281
71282 }
71283
71284
71285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71286   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71287   Dali::Actor arg2 ;
71288   Dali::Actor *argp2 ;
71289
71290   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71291   argp2 = (Dali::Actor *)jarg2;
71292   if (!argp2) {
71293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71294     return ;
71295   }
71296   arg2 = *argp2;
71297   {
71298     try {
71299       (arg1)->SetSelectedImage(arg2);
71300     } catch (std::out_of_range& e) {
71301       {
71302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71303       };
71304     } catch (std::exception& e) {
71305       {
71306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71307       };
71308     } catch (Dali::DaliException e) {
71309       {
71310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71311       };
71312     } catch (...) {
71313       {
71314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71315       };
71316     }
71317   }
71318
71319 }
71320
71321
71322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71323   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71324   Dali::Actor arg2 ;
71325   Dali::Actor *argp2 ;
71326
71327   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71328   argp2 = (Dali::Actor *)jarg2;
71329   if (!argp2) {
71330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71331     return ;
71332   }
71333   arg2 = *argp2;
71334   {
71335     try {
71336       (arg1)->SetSelectedBackgroundImage(arg2);
71337     } catch (std::out_of_range& e) {
71338       {
71339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71340       };
71341     } catch (std::exception& e) {
71342       {
71343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71344       };
71345     } catch (Dali::DaliException e) {
71346       {
71347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71348       };
71349     } catch (...) {
71350       {
71351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71352       };
71353     }
71354   }
71355
71356 }
71357
71358
71359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71360   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71361   Dali::Actor arg2 ;
71362   Dali::Actor *argp2 ;
71363
71364   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71365   argp2 = (Dali::Actor *)jarg2;
71366   if (!argp2) {
71367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71368     return ;
71369   }
71370   arg2 = *argp2;
71371   {
71372     try {
71373       (arg1)->SetDisabledBackgroundImage(arg2);
71374     } catch (std::out_of_range& e) {
71375       {
71376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71377       };
71378     } catch (std::exception& e) {
71379       {
71380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71381       };
71382     } catch (Dali::DaliException e) {
71383       {
71384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71385       };
71386     } catch (...) {
71387       {
71388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71389       };
71390     }
71391   }
71392
71393 }
71394
71395
71396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71397   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71398   Dali::Actor arg2 ;
71399   Dali::Actor *argp2 ;
71400
71401   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71402   argp2 = (Dali::Actor *)jarg2;
71403   if (!argp2) {
71404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71405     return ;
71406   }
71407   arg2 = *argp2;
71408   {
71409     try {
71410       (arg1)->SetDisabledImage(arg2);
71411     } catch (std::out_of_range& e) {
71412       {
71413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71414       };
71415     } catch (std::exception& e) {
71416       {
71417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71418       };
71419     } catch (Dali::DaliException e) {
71420       {
71421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71422       };
71423     } catch (...) {
71424       {
71425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71426       };
71427     }
71428   }
71429
71430 }
71431
71432
71433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71434   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71435   Dali::Actor arg2 ;
71436   Dali::Actor *argp2 ;
71437
71438   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71439   argp2 = (Dali::Actor *)jarg2;
71440   if (!argp2) {
71441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71442     return ;
71443   }
71444   arg2 = *argp2;
71445   {
71446     try {
71447       (arg1)->SetDisabledSelectedImage(arg2);
71448     } catch (std::out_of_range& e) {
71449       {
71450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71451       };
71452     } catch (std::exception& e) {
71453       {
71454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71455       };
71456     } catch (Dali::DaliException e) {
71457       {
71458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71459       };
71460     } catch (...) {
71461       {
71462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71463       };
71464     }
71465   }
71466
71467 }
71468
71469
71470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71471   void * jresult ;
71472   Dali::Toolkit::RadioButton *result = 0 ;
71473
71474   {
71475     try {
71476       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71477     } catch (std::out_of_range& e) {
71478       {
71479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71480       };
71481     } catch (std::exception& e) {
71482       {
71483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71484       };
71485     } catch (Dali::DaliException e) {
71486       {
71487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71488       };
71489     } catch (...) {
71490       {
71491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71492       };
71493     }
71494   }
71495
71496   jresult = (void *)result;
71497   return jresult;
71498 }
71499
71500
71501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71502   void * jresult ;
71503   Dali::Toolkit::RadioButton *arg1 = 0 ;
71504   Dali::Toolkit::RadioButton *result = 0 ;
71505
71506   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71507   if (!arg1) {
71508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71509     return 0;
71510   }
71511   {
71512     try {
71513       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71514     } catch (std::out_of_range& e) {
71515       {
71516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71517       };
71518     } catch (std::exception& e) {
71519       {
71520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71521       };
71522     } catch (Dali::DaliException e) {
71523       {
71524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71525       };
71526     } catch (...) {
71527       {
71528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71529       };
71530     }
71531   }
71532
71533   jresult = (void *)result;
71534   return jresult;
71535 }
71536
71537
71538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71539   void * jresult ;
71540   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71541   Dali::Toolkit::RadioButton *arg2 = 0 ;
71542   Dali::Toolkit::RadioButton *result = 0 ;
71543
71544   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71545   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71546   if (!arg2) {
71547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71548     return 0;
71549   }
71550   {
71551     try {
71552       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71553     } catch (std::out_of_range& e) {
71554       {
71555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71556       };
71557     } catch (std::exception& e) {
71558       {
71559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71560       };
71561     } catch (Dali::DaliException e) {
71562       {
71563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71564       };
71565     } catch (...) {
71566       {
71567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71568       };
71569     }
71570   }
71571
71572   jresult = (void *)result;
71573   return jresult;
71574 }
71575
71576
71577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71578   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71579
71580   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71581   {
71582     try {
71583       delete arg1;
71584     } catch (std::out_of_range& e) {
71585       {
71586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71587       };
71588     } catch (std::exception& e) {
71589       {
71590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71591       };
71592     } catch (Dali::DaliException e) {
71593       {
71594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71595       };
71596     } catch (...) {
71597       {
71598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71599       };
71600     }
71601   }
71602
71603 }
71604
71605
71606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71607   void * jresult ;
71608   Dali::Toolkit::RadioButton result;
71609
71610   {
71611     try {
71612       result = Dali::Toolkit::RadioButton::New();
71613     } catch (std::out_of_range& e) {
71614       {
71615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71616       };
71617     } catch (std::exception& e) {
71618       {
71619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71620       };
71621     } catch (Dali::DaliException e) {
71622       {
71623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71624       };
71625     } catch (...) {
71626       {
71627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71628       };
71629     }
71630   }
71631
71632   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71633   return jresult;
71634 }
71635
71636
71637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71638   void * jresult ;
71639   std::string *arg1 = 0 ;
71640   Dali::Toolkit::RadioButton result;
71641
71642   if (!jarg1) {
71643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71644     return 0;
71645   }
71646   std::string arg1_str(jarg1);
71647   arg1 = &arg1_str;
71648   {
71649     try {
71650       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71651     } catch (std::out_of_range& e) {
71652       {
71653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71654       };
71655     } catch (std::exception& e) {
71656       {
71657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71658       };
71659     } catch (Dali::DaliException e) {
71660       {
71661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71662       };
71663     } catch (...) {
71664       {
71665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71666       };
71667     }
71668   }
71669
71670   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71671
71672   //argout typemap for const std::string&
71673
71674   return jresult;
71675 }
71676
71677
71678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71679   void * jresult ;
71680   Dali::BaseHandle arg1 ;
71681   Dali::BaseHandle *argp1 ;
71682   Dali::Toolkit::RadioButton result;
71683
71684   argp1 = (Dali::BaseHandle *)jarg1;
71685   if (!argp1) {
71686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71687     return 0;
71688   }
71689   arg1 = *argp1;
71690   {
71691     try {
71692       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71693     } catch (std::out_of_range& e) {
71694       {
71695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71696       };
71697     } catch (std::exception& e) {
71698       {
71699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71700       };
71701     } catch (Dali::DaliException e) {
71702       {
71703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71704       };
71705     } catch (...) {
71706       {
71707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71708       };
71709     }
71710   }
71711
71712   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71713   return jresult;
71714 }
71715
71716
71717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71718   int jresult ;
71719   int result;
71720
71721   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71722   jresult = (int)result;
71723   return jresult;
71724 }
71725
71726
71727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71728   int jresult ;
71729   int result;
71730
71731   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71732   jresult = (int)result;
71733   return jresult;
71734 }
71735
71736
71737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71738   int jresult ;
71739   int result;
71740
71741   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71742   jresult = (int)result;
71743   return jresult;
71744 }
71745
71746
71747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71748   int jresult ;
71749   int result;
71750
71751   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71752   jresult = (int)result;
71753   return jresult;
71754 }
71755
71756
71757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71758   int jresult ;
71759   int result;
71760
71761   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71762   jresult = (int)result;
71763   return jresult;
71764 }
71765
71766
71767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71768   int jresult ;
71769   int result;
71770
71771   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71772   jresult = (int)result;
71773   return jresult;
71774 }
71775
71776
71777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71778   void * jresult ;
71779   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71780
71781   {
71782     try {
71783       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71784     } catch (std::out_of_range& e) {
71785       {
71786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71787       };
71788     } catch (std::exception& e) {
71789       {
71790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71791       };
71792     } catch (Dali::DaliException e) {
71793       {
71794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71795       };
71796     } catch (...) {
71797       {
71798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71799       };
71800     }
71801   }
71802
71803   jresult = (void *)result;
71804   return jresult;
71805 }
71806
71807
71808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71809   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71810
71811   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71812   {
71813     try {
71814       delete arg1;
71815     } catch (std::out_of_range& e) {
71816       {
71817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71818       };
71819     } catch (std::exception& e) {
71820       {
71821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71822       };
71823     } catch (Dali::DaliException e) {
71824       {
71825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71826       };
71827     } catch (...) {
71828       {
71829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71830       };
71831     }
71832   }
71833
71834 }
71835
71836
71837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71838   int jresult ;
71839   int result;
71840
71841   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71842   jresult = (int)result;
71843   return jresult;
71844 }
71845
71846
71847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71848   int jresult ;
71849   int result;
71850
71851   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71852   jresult = (int)result;
71853   return jresult;
71854 }
71855
71856
71857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71858   int jresult ;
71859   int result;
71860
71861   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71862   jresult = (int)result;
71863   return jresult;
71864 }
71865
71866
71867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71868   void * jresult ;
71869   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71870
71871   {
71872     try {
71873       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71874     } catch (std::out_of_range& e) {
71875       {
71876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71877       };
71878     } catch (std::exception& e) {
71879       {
71880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71881       };
71882     } catch (Dali::DaliException e) {
71883       {
71884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71885       };
71886     } catch (...) {
71887       {
71888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71889       };
71890     }
71891   }
71892
71893   jresult = (void *)result;
71894   return jresult;
71895 }
71896
71897
71898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71899   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71900
71901   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71902   {
71903     try {
71904       delete arg1;
71905     } catch (std::out_of_range& e) {
71906       {
71907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71908       };
71909     } catch (std::exception& e) {
71910       {
71911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71912       };
71913     } catch (Dali::DaliException e) {
71914       {
71915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71916       };
71917     } catch (...) {
71918       {
71919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71920       };
71921     }
71922   }
71923
71924 }
71925
71926
71927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71928   void * jresult ;
71929   Dali::Toolkit::FlexContainer *result = 0 ;
71930
71931   {
71932     try {
71933       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71934     } catch (std::out_of_range& e) {
71935       {
71936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71937       };
71938     } catch (std::exception& e) {
71939       {
71940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71941       };
71942     } catch (Dali::DaliException e) {
71943       {
71944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71945       };
71946     } catch (...) {
71947       {
71948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71949       };
71950     }
71951   }
71952
71953   jresult = (void *)result;
71954   return jresult;
71955 }
71956
71957
71958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71959   void * jresult ;
71960   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71961   Dali::Toolkit::FlexContainer *result = 0 ;
71962
71963   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71964   if (!arg1) {
71965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71966     return 0;
71967   }
71968   {
71969     try {
71970       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71971     } catch (std::out_of_range& e) {
71972       {
71973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71974       };
71975     } catch (std::exception& e) {
71976       {
71977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71978       };
71979     } catch (Dali::DaliException e) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71982       };
71983     } catch (...) {
71984       {
71985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71986       };
71987     }
71988   }
71989
71990   jresult = (void *)result;
71991   return jresult;
71992 }
71993
71994
71995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71996   void * jresult ;
71997   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71998   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71999   Dali::Toolkit::FlexContainer *result = 0 ;
72000
72001   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72002   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
72003   if (!arg2) {
72004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
72005     return 0;
72006   }
72007   {
72008     try {
72009       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
72010     } catch (std::out_of_range& e) {
72011       {
72012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72013       };
72014     } catch (std::exception& e) {
72015       {
72016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72017       };
72018     } catch (Dali::DaliException e) {
72019       {
72020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72021       };
72022     } catch (...) {
72023       {
72024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72025       };
72026     }
72027   }
72028
72029   jresult = (void *)result;
72030   return jresult;
72031 }
72032
72033
72034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
72035   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72036
72037   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72038   {
72039     try {
72040       delete arg1;
72041     } catch (std::out_of_range& e) {
72042       {
72043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72044       };
72045     } catch (std::exception& e) {
72046       {
72047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72048       };
72049     } catch (Dali::DaliException e) {
72050       {
72051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72052       };
72053     } catch (...) {
72054       {
72055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72056       };
72057     }
72058   }
72059
72060 }
72061
72062
72063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
72064   void * jresult ;
72065   Dali::Toolkit::FlexContainer result;
72066
72067   {
72068     try {
72069       result = Dali::Toolkit::FlexContainer::New();
72070     } catch (std::out_of_range& e) {
72071       {
72072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72073       };
72074     } catch (std::exception& e) {
72075       {
72076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72077       };
72078     } catch (Dali::DaliException e) {
72079       {
72080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72081       };
72082     } catch (...) {
72083       {
72084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72085       };
72086     }
72087   }
72088
72089   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72090   return jresult;
72091 }
72092
72093
72094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72095   void * jresult ;
72096   Dali::BaseHandle arg1 ;
72097   Dali::BaseHandle *argp1 ;
72098   Dali::Toolkit::FlexContainer result;
72099
72100   argp1 = (Dali::BaseHandle *)jarg1;
72101   if (!argp1) {
72102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72103     return 0;
72104   }
72105   arg1 = *argp1;
72106   {
72107     try {
72108       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72109     } catch (std::out_of_range& e) {
72110       {
72111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72112       };
72113     } catch (std::exception& e) {
72114       {
72115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72116       };
72117     } catch (Dali::DaliException e) {
72118       {
72119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72120       };
72121     } catch (...) {
72122       {
72123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72124       };
72125     }
72126   }
72127
72128   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72129   return jresult;
72130 }
72131
72132
72133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72134   int jresult ;
72135   int result;
72136
72137   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72138   jresult = (int)result;
72139   return jresult;
72140 }
72141
72142
72143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72144   int jresult ;
72145   int result;
72146
72147   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72148   jresult = (int)result;
72149   return jresult;
72150 }
72151
72152
72153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72154   int jresult ;
72155   int result;
72156
72157   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72158   jresult = (int)result;
72159   return jresult;
72160 }
72161
72162
72163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72164   int jresult ;
72165   int result;
72166
72167   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72168   jresult = (int)result;
72169   return jresult;
72170 }
72171
72172
72173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72174   void * jresult ;
72175   Dali::Toolkit::ImageView::Property *result = 0 ;
72176
72177   {
72178     try {
72179       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72180     } catch (std::out_of_range& e) {
72181       {
72182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72183       };
72184     } catch (std::exception& e) {
72185       {
72186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72187       };
72188     } catch (Dali::DaliException e) {
72189       {
72190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72191       };
72192     } catch (...) {
72193       {
72194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72195       };
72196     }
72197   }
72198
72199   jresult = (void *)result;
72200   return jresult;
72201 }
72202
72203
72204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72205   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72206
72207   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72208   {
72209     try {
72210       delete arg1;
72211     } catch (std::out_of_range& e) {
72212       {
72213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72214       };
72215     } catch (std::exception& e) {
72216       {
72217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72218       };
72219     } catch (Dali::DaliException e) {
72220       {
72221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72222       };
72223     } catch (...) {
72224       {
72225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72226       };
72227     }
72228   }
72229
72230 }
72231
72232
72233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72234   void * jresult ;
72235   Dali::Toolkit::ImageView *result = 0 ;
72236
72237   {
72238     try {
72239       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72240     } catch (std::out_of_range& e) {
72241       {
72242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72243       };
72244     } catch (std::exception& e) {
72245       {
72246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72247       };
72248     } catch (Dali::DaliException e) {
72249       {
72250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72251       };
72252     } catch (...) {
72253       {
72254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72255       };
72256     }
72257   }
72258
72259   jresult = (void *)result;
72260   return jresult;
72261 }
72262
72263
72264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72265   void * jresult ;
72266   Dali::Toolkit::ImageView result;
72267
72268   {
72269     try {
72270       result = Dali::Toolkit::ImageView::New();
72271     } catch (std::out_of_range& e) {
72272       {
72273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72274       };
72275     } catch (std::exception& e) {
72276       {
72277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72278       };
72279     } catch (Dali::DaliException e) {
72280       {
72281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72282       };
72283     } catch (...) {
72284       {
72285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72286       };
72287     }
72288   }
72289
72290   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72291   return jresult;
72292 }
72293
72294
72295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72296   void * jresult ;
72297   Dali::Image arg1 ;
72298   Dali::Image *argp1 ;
72299   Dali::Toolkit::ImageView result;
72300
72301   argp1 = (Dali::Image *)jarg1;
72302   if (!argp1) {
72303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72304     return 0;
72305   }
72306   arg1 = *argp1;
72307   {
72308     try {
72309       result = Dali::Toolkit::ImageView::New(arg1);
72310     } catch (std::out_of_range& e) {
72311       {
72312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72313       };
72314     } catch (std::exception& e) {
72315       {
72316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72317       };
72318     } catch (Dali::DaliException e) {
72319       {
72320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72321       };
72322     } catch (...) {
72323       {
72324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72325       };
72326     }
72327   }
72328
72329   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72330   return jresult;
72331 }
72332
72333
72334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72335   void * jresult ;
72336   std::string *arg1 = 0 ;
72337   Dali::Toolkit::ImageView result;
72338
72339   if (!jarg1) {
72340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72341     return 0;
72342   }
72343   std::string arg1_str(jarg1);
72344   arg1 = &arg1_str;
72345   {
72346     try {
72347       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72348     } catch (std::out_of_range& e) {
72349       {
72350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72351       };
72352     } catch (std::exception& e) {
72353       {
72354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72355       };
72356     } catch (Dali::DaliException e) {
72357       {
72358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72359       };
72360     } catch (...) {
72361       {
72362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72363       };
72364     }
72365   }
72366
72367   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72368
72369   //argout typemap for const std::string&
72370
72371   return jresult;
72372 }
72373
72374
72375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72376   void * jresult ;
72377   std::string *arg1 = 0 ;
72378   Dali::ImageDimensions arg2 ;
72379   Dali::ImageDimensions *argp2 ;
72380   Dali::Toolkit::ImageView result;
72381
72382   if (!jarg1) {
72383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72384     return 0;
72385   }
72386   std::string arg1_str(jarg1);
72387   arg1 = &arg1_str;
72388   argp2 = (Dali::ImageDimensions *)jarg2;
72389   if (!argp2) {
72390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72391     return 0;
72392   }
72393   arg2 = *argp2;
72394   {
72395     try {
72396       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72397     } catch (std::out_of_range& e) {
72398       {
72399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72400       };
72401     } catch (std::exception& e) {
72402       {
72403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72404       };
72405     } catch (Dali::DaliException e) {
72406       {
72407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72408       };
72409     } catch (...) {
72410       {
72411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72412       };
72413     }
72414   }
72415
72416   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72417
72418   //argout typemap for const std::string&
72419
72420   return jresult;
72421 }
72422
72423
72424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72425   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72426
72427   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72428   {
72429     try {
72430       delete arg1;
72431     } catch (std::out_of_range& e) {
72432       {
72433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72434       };
72435     } catch (std::exception& e) {
72436       {
72437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72438       };
72439     } catch (Dali::DaliException e) {
72440       {
72441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72442       };
72443     } catch (...) {
72444       {
72445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72446       };
72447     }
72448   }
72449
72450 }
72451
72452
72453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72454   void * jresult ;
72455   Dali::Toolkit::ImageView *arg1 = 0 ;
72456   Dali::Toolkit::ImageView *result = 0 ;
72457
72458   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72459   if (!arg1) {
72460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72461     return 0;
72462   }
72463   {
72464     try {
72465       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72466     } catch (std::out_of_range& e) {
72467       {
72468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72469       };
72470     } catch (std::exception& e) {
72471       {
72472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72473       };
72474     } catch (Dali::DaliException e) {
72475       {
72476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72477       };
72478     } catch (...) {
72479       {
72480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72481       };
72482     }
72483   }
72484
72485   jresult = (void *)result;
72486   return jresult;
72487 }
72488
72489
72490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72491   void * jresult ;
72492   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72493   Dali::Toolkit::ImageView *arg2 = 0 ;
72494   Dali::Toolkit::ImageView *result = 0 ;
72495
72496   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72497   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72498   if (!arg2) {
72499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72500     return 0;
72501   }
72502   {
72503     try {
72504       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72505     } catch (std::out_of_range& e) {
72506       {
72507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72508       };
72509     } catch (std::exception& e) {
72510       {
72511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72512       };
72513     } catch (Dali::DaliException e) {
72514       {
72515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72516       };
72517     } catch (...) {
72518       {
72519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72520       };
72521     }
72522   }
72523
72524   jresult = (void *)result;
72525   return jresult;
72526 }
72527
72528
72529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72530   void * jresult ;
72531   Dali::BaseHandle arg1 ;
72532   Dali::BaseHandle *argp1 ;
72533   Dali::Toolkit::ImageView result;
72534
72535   argp1 = (Dali::BaseHandle *)jarg1;
72536   if (!argp1) {
72537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72538     return 0;
72539   }
72540   arg1 = *argp1;
72541   {
72542     try {
72543       result = Dali::Toolkit::ImageView::DownCast(arg1);
72544     } catch (std::out_of_range& e) {
72545       {
72546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72547       };
72548     } catch (std::exception& e) {
72549       {
72550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72551       };
72552     } catch (Dali::DaliException e) {
72553       {
72554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72555       };
72556     } catch (...) {
72557       {
72558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72559       };
72560     }
72561   }
72562
72563   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72564   return jresult;
72565 }
72566
72567
72568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72569   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72570   Dali::Image arg2 ;
72571   Dali::Image *argp2 ;
72572
72573   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72574   argp2 = (Dali::Image *)jarg2;
72575   if (!argp2) {
72576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72577     return ;
72578   }
72579   arg2 = *argp2;
72580   {
72581     try {
72582       (arg1)->SetImage(arg2);
72583     } catch (std::out_of_range& e) {
72584       {
72585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72586       };
72587     } catch (std::exception& e) {
72588       {
72589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72590       };
72591     } catch (Dali::DaliException e) {
72592       {
72593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72594       };
72595     } catch (...) {
72596       {
72597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72598       };
72599     }
72600   }
72601
72602 }
72603
72604
72605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72606   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72607   std::string *arg2 = 0 ;
72608
72609   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72610   if (!jarg2) {
72611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72612     return ;
72613   }
72614   std::string arg2_str(jarg2);
72615   arg2 = &arg2_str;
72616   {
72617     try {
72618       (arg1)->SetImage((std::string const &)*arg2);
72619     } catch (std::out_of_range& e) {
72620       {
72621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72622       };
72623     } catch (std::exception& e) {
72624       {
72625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72626       };
72627     } catch (Dali::DaliException e) {
72628       {
72629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72630       };
72631     } catch (...) {
72632       {
72633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72634       };
72635     }
72636   }
72637
72638
72639   //argout typemap for const std::string&
72640
72641 }
72642
72643
72644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72645   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72646   std::string *arg2 = 0 ;
72647   Dali::ImageDimensions arg3 ;
72648   Dali::ImageDimensions *argp3 ;
72649
72650   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72651   if (!jarg2) {
72652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72653     return ;
72654   }
72655   std::string arg2_str(jarg2);
72656   arg2 = &arg2_str;
72657   argp3 = (Dali::ImageDimensions *)jarg3;
72658   if (!argp3) {
72659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72660     return ;
72661   }
72662   arg3 = *argp3;
72663   {
72664     try {
72665       (arg1)->SetImage((std::string const &)*arg2,arg3);
72666     } catch (std::out_of_range& e) {
72667       {
72668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72669       };
72670     } catch (std::exception& e) {
72671       {
72672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72673       };
72674     } catch (Dali::DaliException e) {
72675       {
72676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72677       };
72678     } catch (...) {
72679       {
72680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72681       };
72682     }
72683   }
72684
72685
72686   //argout typemap for const std::string&
72687
72688 }
72689
72690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72691   void * jresult ;
72692   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72693   Dali::Image result;
72694
72695   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72696   {
72697     try {
72698       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72699     } catch (std::out_of_range& e) {
72700       {
72701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72702       };
72703     } catch (std::exception& e) {
72704       {
72705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72706       };
72707     } catch (Dali::DaliException e) {
72708       {
72709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72710       };
72711     } catch (...) {
72712       {
72713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72714       };
72715     }
72716   }
72717
72718   jresult = new Dali::Image((const Dali::Image &)result);
72719   return jresult;
72720 }
72721
72722
72723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72724   int jresult ;
72725   int result;
72726
72727   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72728   jresult = (int)result;
72729   return jresult;
72730 }
72731
72732
72733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72734   int jresult ;
72735   int result;
72736
72737   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72738   jresult = (int)result;
72739   return jresult;
72740 }
72741
72742
72743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72744   int jresult ;
72745   int result;
72746
72747   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72748   jresult = (int)result;
72749   return jresult;
72750 }
72751
72752
72753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72754   int jresult ;
72755   int result;
72756
72757   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72758   jresult = (int)result;
72759   return jresult;
72760 }
72761
72762
72763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72764   int jresult ;
72765   int result;
72766
72767   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72768   jresult = (int)result;
72769   return jresult;
72770 }
72771
72772
72773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72774   int jresult ;
72775   int result;
72776
72777   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72778   jresult = (int)result;
72779   return jresult;
72780 }
72781
72782
72783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72784   int jresult ;
72785   int result;
72786
72787   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72788   jresult = (int)result;
72789   return jresult;
72790 }
72791
72792
72793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72794   int jresult ;
72795   int result;
72796
72797   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72798   jresult = (int)result;
72799   return jresult;
72800 }
72801
72802
72803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72804   void * jresult ;
72805   Dali::Toolkit::Model3dView::Property *result = 0 ;
72806
72807   {
72808     try {
72809       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72810     } catch (std::out_of_range& e) {
72811       {
72812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72813       };
72814     } catch (std::exception& e) {
72815       {
72816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72817       };
72818     } catch (Dali::DaliException e) {
72819       {
72820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72821       };
72822     } catch (...) {
72823       {
72824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72825       };
72826     }
72827   }
72828
72829   jresult = (void *)result;
72830   return jresult;
72831 }
72832
72833
72834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72835   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72836
72837   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72838   {
72839     try {
72840       delete arg1;
72841     } catch (std::out_of_range& e) {
72842       {
72843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72844       };
72845     } catch (std::exception& e) {
72846       {
72847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72848       };
72849     } catch (Dali::DaliException e) {
72850       {
72851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72852       };
72853     } catch (...) {
72854       {
72855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72856       };
72857     }
72858   }
72859
72860 }
72861
72862
72863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72864   void * jresult ;
72865   Dali::Toolkit::Model3dView result;
72866
72867   {
72868     try {
72869       result = Dali::Toolkit::Model3dView::New();
72870     } catch (std::out_of_range& e) {
72871       {
72872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72873       };
72874     } catch (std::exception& e) {
72875       {
72876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72877       };
72878     } catch (Dali::DaliException e) {
72879       {
72880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72881       };
72882     } catch (...) {
72883       {
72884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72885       };
72886     }
72887   }
72888
72889   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72890   return jresult;
72891 }
72892
72893
72894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72895   void * jresult ;
72896   std::string *arg1 = 0 ;
72897   std::string *arg2 = 0 ;
72898   std::string *arg3 = 0 ;
72899   Dali::Toolkit::Model3dView result;
72900
72901   if (!jarg1) {
72902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72903     return 0;
72904   }
72905   std::string arg1_str(jarg1);
72906   arg1 = &arg1_str;
72907   if (!jarg2) {
72908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72909     return 0;
72910   }
72911   std::string arg2_str(jarg2);
72912   arg2 = &arg2_str;
72913   if (!jarg3) {
72914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72915     return 0;
72916   }
72917   std::string arg3_str(jarg3);
72918   arg3 = &arg3_str;
72919   {
72920     try {
72921       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72922     } catch (std::out_of_range& e) {
72923       {
72924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72925       };
72926     } catch (std::exception& e) {
72927       {
72928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72929       };
72930     } catch (Dali::DaliException e) {
72931       {
72932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72933       };
72934     } catch (...) {
72935       {
72936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72937       };
72938     }
72939   }
72940
72941   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72942
72943   //argout typemap for const std::string&
72944
72945
72946   //argout typemap for const std::string&
72947
72948
72949   //argout typemap for const std::string&
72950
72951   return jresult;
72952 }
72953
72954
72955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72956   void * jresult ;
72957   Dali::Toolkit::Model3dView *result = 0 ;
72958
72959   {
72960     try {
72961       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72962     } catch (std::out_of_range& e) {
72963       {
72964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72965       };
72966     } catch (std::exception& e) {
72967       {
72968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72969       };
72970     } catch (Dali::DaliException e) {
72971       {
72972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72973       };
72974     } catch (...) {
72975       {
72976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72977       };
72978     }
72979   }
72980
72981   jresult = (void *)result;
72982   return jresult;
72983 }
72984
72985
72986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72987   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72988
72989   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72990   {
72991     try {
72992       delete arg1;
72993     } catch (std::out_of_range& e) {
72994       {
72995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72996       };
72997     } catch (std::exception& e) {
72998       {
72999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73000       };
73001     } catch (Dali::DaliException e) {
73002       {
73003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73004       };
73005     } catch (...) {
73006       {
73007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73008       };
73009     }
73010   }
73011
73012 }
73013
73014
73015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
73016   void * jresult ;
73017   Dali::Toolkit::Model3dView *arg1 = 0 ;
73018   Dali::Toolkit::Model3dView *result = 0 ;
73019
73020   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73021   if (!arg1) {
73022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73023     return 0;
73024   }
73025   {
73026     try {
73027       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
73028     } catch (std::out_of_range& e) {
73029       {
73030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73031       };
73032     } catch (std::exception& e) {
73033       {
73034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73035       };
73036     } catch (Dali::DaliException e) {
73037       {
73038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73039       };
73040     } catch (...) {
73041       {
73042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73043       };
73044     }
73045   }
73046
73047   jresult = (void *)result;
73048   return jresult;
73049 }
73050
73051
73052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
73053   void * jresult ;
73054   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73055   Dali::Toolkit::Model3dView *arg2 = 0 ;
73056   Dali::Toolkit::Model3dView *result = 0 ;
73057
73058   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73059   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
73060   if (!arg2) {
73061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73062     return 0;
73063   }
73064   {
73065     try {
73066       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
73067     } catch (std::out_of_range& e) {
73068       {
73069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73070       };
73071     } catch (std::exception& e) {
73072       {
73073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73074       };
73075     } catch (Dali::DaliException e) {
73076       {
73077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73078       };
73079     } catch (...) {
73080       {
73081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73082       };
73083     }
73084   }
73085
73086   jresult = (void *)result;
73087   return jresult;
73088 }
73089
73090
73091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73092   void * jresult ;
73093   Dali::BaseHandle arg1 ;
73094   Dali::BaseHandle *argp1 ;
73095   Dali::Toolkit::Model3dView result;
73096
73097   argp1 = (Dali::BaseHandle *)jarg1;
73098   if (!argp1) {
73099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73100     return 0;
73101   }
73102   arg1 = *argp1;
73103   {
73104     try {
73105       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73106     } catch (std::out_of_range& e) {
73107       {
73108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73109       };
73110     } catch (std::exception& e) {
73111       {
73112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73113       };
73114     } catch (Dali::DaliException e) {
73115       {
73116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73117       };
73118     } catch (...) {
73119       {
73120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73121       };
73122     }
73123   }
73124
73125   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73126   return jresult;
73127 }
73128
73129
73130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73131   int jresult ;
73132   int result;
73133
73134   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73135   jresult = (int)result;
73136   return jresult;
73137 }
73138
73139
73140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73141   int jresult ;
73142   int result;
73143
73144   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73145   jresult = (int)result;
73146   return jresult;
73147 }
73148
73149
73150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73151   int jresult ;
73152   int result;
73153
73154   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73155   jresult = (int)result;
73156   return jresult;
73157 }
73158
73159
73160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73161   int jresult ;
73162   int result;
73163
73164   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73165   jresult = (int)result;
73166   return jresult;
73167 }
73168
73169
73170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73171   int jresult ;
73172   int result;
73173
73174   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73175   jresult = (int)result;
73176   return jresult;
73177 }
73178
73179
73180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73181   int jresult ;
73182   int result;
73183
73184   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73185   jresult = (int)result;
73186   return jresult;
73187 }
73188
73189
73190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73191   int jresult ;
73192   int result;
73193
73194   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73195   jresult = (int)result;
73196   return jresult;
73197 }
73198
73199
73200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73201   int jresult ;
73202   int result;
73203
73204   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73205   jresult = (int)result;
73206   return jresult;
73207 }
73208
73209
73210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73211   int jresult ;
73212   int result;
73213
73214   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73215   jresult = (int)result;
73216   return jresult;
73217 }
73218
73219
73220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73221   void * jresult ;
73222   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73223
73224   {
73225     try {
73226       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73227     } catch (std::out_of_range& e) {
73228       {
73229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73230       };
73231     } catch (std::exception& e) {
73232       {
73233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73234       };
73235     } catch (Dali::DaliException e) {
73236       {
73237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73238       };
73239     } catch (...) {
73240       {
73241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73242       };
73243     }
73244   }
73245
73246   jresult = (void *)result;
73247   return jresult;
73248 }
73249
73250
73251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73252   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73253
73254   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73255   {
73256     try {
73257       delete arg1;
73258     } catch (std::out_of_range& e) {
73259       {
73260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73261       };
73262     } catch (std::exception& e) {
73263       {
73264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73265       };
73266     } catch (Dali::DaliException e) {
73267       {
73268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73269       };
73270     } catch (...) {
73271       {
73272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73273       };
73274     }
73275   }
73276
73277 }
73278
73279
73280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73281   void * jresult ;
73282   Dali::Toolkit::ScrollBar *result = 0 ;
73283
73284   {
73285     try {
73286       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73287     } catch (std::out_of_range& e) {
73288       {
73289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73290       };
73291     } catch (std::exception& e) {
73292       {
73293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73294       };
73295     } catch (Dali::DaliException e) {
73296       {
73297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73298       };
73299     } catch (...) {
73300       {
73301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73302       };
73303     }
73304   }
73305
73306   jresult = (void *)result;
73307   return jresult;
73308 }
73309
73310
73311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73312   void * jresult ;
73313   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73314   Dali::Toolkit::ScrollBar *result = 0 ;
73315
73316   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73317   if (!arg1) {
73318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73319     return 0;
73320   }
73321   {
73322     try {
73323       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73324     } catch (std::out_of_range& e) {
73325       {
73326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73327       };
73328     } catch (std::exception& e) {
73329       {
73330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73331       };
73332     } catch (Dali::DaliException e) {
73333       {
73334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73335       };
73336     } catch (...) {
73337       {
73338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73339       };
73340     }
73341   }
73342
73343   jresult = (void *)result;
73344   return jresult;
73345 }
73346
73347
73348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73349   void * jresult ;
73350   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73351   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73352   Dali::Toolkit::ScrollBar *result = 0 ;
73353
73354   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73355   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73356   if (!arg2) {
73357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73358     return 0;
73359   }
73360   {
73361     try {
73362       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73363     } catch (std::out_of_range& e) {
73364       {
73365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73366       };
73367     } catch (std::exception& e) {
73368       {
73369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73370       };
73371     } catch (Dali::DaliException e) {
73372       {
73373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73374       };
73375     } catch (...) {
73376       {
73377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73378       };
73379     }
73380   }
73381
73382   jresult = (void *)result;
73383   return jresult;
73384 }
73385
73386
73387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73388   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73389
73390   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73391   {
73392     try {
73393       delete arg1;
73394     } catch (std::out_of_range& e) {
73395       {
73396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73397       };
73398     } catch (std::exception& e) {
73399       {
73400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73401       };
73402     } catch (Dali::DaliException e) {
73403       {
73404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73405       };
73406     } catch (...) {
73407       {
73408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73409       };
73410     }
73411   }
73412
73413 }
73414
73415
73416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73417   void * jresult ;
73418   Dali::Toolkit::ScrollBar::Direction arg1 ;
73419   Dali::Toolkit::ScrollBar result;
73420
73421   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73422   {
73423     try {
73424       result = Dali::Toolkit::ScrollBar::New(arg1);
73425     } catch (std::out_of_range& e) {
73426       {
73427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73428       };
73429     } catch (std::exception& e) {
73430       {
73431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73432       };
73433     } catch (Dali::DaliException e) {
73434       {
73435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73436       };
73437     } catch (...) {
73438       {
73439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73440       };
73441     }
73442   }
73443
73444   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73445   return jresult;
73446 }
73447
73448
73449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73450   void * jresult ;
73451   Dali::Toolkit::ScrollBar result;
73452
73453   {
73454     try {
73455       result = Dali::Toolkit::ScrollBar::New();
73456     } catch (std::out_of_range& e) {
73457       {
73458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73459       };
73460     } catch (std::exception& e) {
73461       {
73462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73463       };
73464     } catch (Dali::DaliException e) {
73465       {
73466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73467       };
73468     } catch (...) {
73469       {
73470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73471       };
73472     }
73473   }
73474
73475   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73476   return jresult;
73477 }
73478
73479
73480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73481   void * jresult ;
73482   Dali::BaseHandle arg1 ;
73483   Dali::BaseHandle *argp1 ;
73484   Dali::Toolkit::ScrollBar result;
73485
73486   argp1 = (Dali::BaseHandle *)jarg1;
73487   if (!argp1) {
73488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73489     return 0;
73490   }
73491   arg1 = *argp1;
73492   {
73493     try {
73494       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73495     } catch (std::out_of_range& e) {
73496       {
73497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73498       };
73499     } catch (std::exception& e) {
73500       {
73501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73502       };
73503     } catch (Dali::DaliException e) {
73504       {
73505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73506       };
73507     } catch (...) {
73508       {
73509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73510       };
73511     }
73512   }
73513
73514   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73515   return jresult;
73516 }
73517
73518
73519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73520   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73521   Dali::Handle arg2 ;
73522   Dali::Property::Index arg3 ;
73523   Dali::Property::Index arg4 ;
73524   Dali::Property::Index arg5 ;
73525   Dali::Property::Index arg6 ;
73526   Dali::Handle *argp2 ;
73527
73528   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73529   argp2 = (Dali::Handle *)jarg2;
73530   if (!argp2) {
73531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73532     return ;
73533   }
73534   arg2 = *argp2;
73535   arg3 = (Dali::Property::Index)jarg3;
73536   arg4 = (Dali::Property::Index)jarg4;
73537   arg5 = (Dali::Property::Index)jarg5;
73538   arg6 = (Dali::Property::Index)jarg6;
73539   {
73540     try {
73541       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73542     } catch (std::out_of_range& e) {
73543       {
73544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73545       };
73546     } catch (std::exception& e) {
73547       {
73548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73549       };
73550     } catch (Dali::DaliException e) {
73551       {
73552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73553       };
73554     } catch (...) {
73555       {
73556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73557       };
73558     }
73559   }
73560
73561 }
73562
73563
73564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73565   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73566   Dali::Actor arg2 ;
73567   Dali::Actor *argp2 ;
73568
73569   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73570   argp2 = (Dali::Actor *)jarg2;
73571   if (!argp2) {
73572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73573     return ;
73574   }
73575   arg2 = *argp2;
73576   {
73577     try {
73578       (arg1)->SetScrollIndicator(arg2);
73579     } catch (std::out_of_range& e) {
73580       {
73581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73582       };
73583     } catch (std::exception& e) {
73584       {
73585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73586       };
73587     } catch (Dali::DaliException e) {
73588       {
73589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73590       };
73591     } catch (...) {
73592       {
73593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73594       };
73595     }
73596   }
73597
73598 }
73599
73600
73601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73602   void * jresult ;
73603   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73604   Dali::Actor result;
73605
73606   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73607   {
73608     try {
73609       result = (arg1)->GetScrollIndicator();
73610     } catch (std::out_of_range& e) {
73611       {
73612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73613       };
73614     } catch (std::exception& e) {
73615       {
73616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73617       };
73618     } catch (Dali::DaliException e) {
73619       {
73620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73621       };
73622     } catch (...) {
73623       {
73624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73625       };
73626     }
73627   }
73628
73629   jresult = new Dali::Actor((const Dali::Actor &)result);
73630   return jresult;
73631 }
73632
73633
73634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73635   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73636   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73637
73638   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73639   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73640   if (!arg2) {
73641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73642     return ;
73643   }
73644   {
73645     try {
73646       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73647     } catch (std::out_of_range& e) {
73648       {
73649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73650       };
73651     } catch (std::exception& e) {
73652       {
73653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73654       };
73655     } catch (Dali::DaliException e) {
73656       {
73657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73658       };
73659     } catch (...) {
73660       {
73661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73662       };
73663     }
73664   }
73665
73666 }
73667
73668
73669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73670   void * jresult ;
73671   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73672
73673   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73674   {
73675     try {
73676       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()));
73677     } catch (std::out_of_range& e) {
73678       {
73679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73680       };
73681     } catch (std::exception& e) {
73682       {
73683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73684       };
73685     } catch (...) {
73686       {
73687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73688       };
73689     }
73690   }
73691   return jresult;
73692 }
73693
73694
73695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73696   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73697   Dali::Toolkit::ScrollBar::Direction arg2 ;
73698
73699   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73700   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73701   {
73702     try {
73703       (arg1)->SetScrollDirection(arg2);
73704     } catch (std::out_of_range& e) {
73705       {
73706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73707       };
73708     } catch (std::exception& e) {
73709       {
73710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73711       };
73712     } catch (Dali::DaliException e) {
73713       {
73714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73715       };
73716     } catch (...) {
73717       {
73718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73719       };
73720     }
73721   }
73722
73723 }
73724
73725
73726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73727   int jresult ;
73728   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73729   Dali::Toolkit::ScrollBar::Direction result;
73730
73731   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73732   {
73733     try {
73734       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73735     } catch (std::out_of_range& e) {
73736       {
73737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73738       };
73739     } catch (std::exception& e) {
73740       {
73741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73742       };
73743     } catch (Dali::DaliException e) {
73744       {
73745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73746       };
73747     } catch (...) {
73748       {
73749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73750       };
73751     }
73752   }
73753
73754   jresult = (int)result;
73755   return jresult;
73756 }
73757
73758
73759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73760   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73761   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73762
73763   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73764   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73765   {
73766     try {
73767       (arg1)->SetIndicatorHeightPolicy(arg2);
73768     } catch (std::out_of_range& e) {
73769       {
73770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73771       };
73772     } catch (std::exception& e) {
73773       {
73774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73775       };
73776     } catch (Dali::DaliException e) {
73777       {
73778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73779       };
73780     } catch (...) {
73781       {
73782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73783       };
73784     }
73785   }
73786
73787 }
73788
73789
73790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73791   int jresult ;
73792   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73793   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73794
73795   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73796   {
73797     try {
73798       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73799     } catch (std::out_of_range& e) {
73800       {
73801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73802       };
73803     } catch (std::exception& e) {
73804       {
73805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73806       };
73807     } catch (Dali::DaliException e) {
73808       {
73809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73810       };
73811     } catch (...) {
73812       {
73813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73814       };
73815     }
73816   }
73817
73818   jresult = (int)result;
73819   return jresult;
73820 }
73821
73822
73823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73824   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73825   float arg2 ;
73826
73827   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73828   arg2 = (float)jarg2;
73829   {
73830     try {
73831       (arg1)->SetIndicatorFixedHeight(arg2);
73832     } catch (std::out_of_range& e) {
73833       {
73834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73835       };
73836     } catch (std::exception& e) {
73837       {
73838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73839       };
73840     } catch (Dali::DaliException e) {
73841       {
73842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73843       };
73844     } catch (...) {
73845       {
73846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73847       };
73848     }
73849   }
73850
73851 }
73852
73853
73854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73855   float jresult ;
73856   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73857   float result;
73858
73859   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73860   {
73861     try {
73862       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73863     } catch (std::out_of_range& e) {
73864       {
73865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73866       };
73867     } catch (std::exception& e) {
73868       {
73869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73870       };
73871     } catch (Dali::DaliException e) {
73872       {
73873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73874       };
73875     } catch (...) {
73876       {
73877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73878       };
73879     }
73880   }
73881
73882   jresult = result;
73883   return jresult;
73884 }
73885
73886
73887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73888   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73889   float arg2 ;
73890
73891   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73892   arg2 = (float)jarg2;
73893   {
73894     try {
73895       (arg1)->SetIndicatorShowDuration(arg2);
73896     } catch (std::out_of_range& e) {
73897       {
73898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73899       };
73900     } catch (std::exception& e) {
73901       {
73902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73903       };
73904     } catch (Dali::DaliException e) {
73905       {
73906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73907       };
73908     } catch (...) {
73909       {
73910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73911       };
73912     }
73913   }
73914
73915 }
73916
73917
73918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73919   float jresult ;
73920   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73921   float result;
73922
73923   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73924   {
73925     try {
73926       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73927     } catch (std::out_of_range& e) {
73928       {
73929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73930       };
73931     } catch (std::exception& e) {
73932       {
73933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73934       };
73935     } catch (Dali::DaliException e) {
73936       {
73937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73938       };
73939     } catch (...) {
73940       {
73941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73942       };
73943     }
73944   }
73945
73946   jresult = result;
73947   return jresult;
73948 }
73949
73950
73951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73952   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73953   float arg2 ;
73954
73955   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73956   arg2 = (float)jarg2;
73957   {
73958     try {
73959       (arg1)->SetIndicatorHideDuration(arg2);
73960     } catch (std::out_of_range& e) {
73961       {
73962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73963       };
73964     } catch (std::exception& e) {
73965       {
73966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73967       };
73968     } catch (Dali::DaliException e) {
73969       {
73970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73971       };
73972     } catch (...) {
73973       {
73974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73975       };
73976     }
73977   }
73978
73979 }
73980
73981
73982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73983   float jresult ;
73984   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73985   float result;
73986
73987   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73988   {
73989     try {
73990       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73991     } catch (std::out_of_range& e) {
73992       {
73993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73994       };
73995     } catch (std::exception& e) {
73996       {
73997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73998       };
73999     } catch (Dali::DaliException e) {
74000       {
74001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74002       };
74003     } catch (...) {
74004       {
74005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74006       };
74007     }
74008   }
74009
74010   jresult = result;
74011   return jresult;
74012 }
74013
74014
74015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
74016   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74017
74018   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74019   {
74020     try {
74021       (arg1)->ShowIndicator();
74022     } catch (std::out_of_range& e) {
74023       {
74024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74025       };
74026     } catch (std::exception& e) {
74027       {
74028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74029       };
74030     } catch (Dali::DaliException e) {
74031       {
74032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74033       };
74034     } catch (...) {
74035       {
74036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74037       };
74038     }
74039   }
74040
74041 }
74042
74043
74044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
74045   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74046
74047   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74048   {
74049     try {
74050       (arg1)->HideIndicator();
74051     } catch (std::out_of_range& e) {
74052       {
74053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74054       };
74055     } catch (std::exception& e) {
74056       {
74057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74058       };
74059     } catch (Dali::DaliException e) {
74060       {
74061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74062       };
74063     } catch (...) {
74064       {
74065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74066       };
74067     }
74068   }
74069
74070 }
74071
74072
74073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74074   void * jresult ;
74075   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74076   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74077
74078   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74079   {
74080     try {
74081       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74082     } catch (std::out_of_range& e) {
74083       {
74084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74085       };
74086     } catch (std::exception& e) {
74087       {
74088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74089       };
74090     } catch (Dali::DaliException e) {
74091       {
74092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74093       };
74094     } catch (...) {
74095       {
74096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74097       };
74098     }
74099   }
74100
74101   jresult = (void *)result;
74102   return jresult;
74103 }
74104
74105
74106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74107   void * jresult ;
74108   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74109   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74110
74111   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74112   {
74113     try {
74114       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74115     } catch (std::out_of_range& e) {
74116       {
74117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74118       };
74119     } catch (std::exception& e) {
74120       {
74121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74122       };
74123     } catch (Dali::DaliException e) {
74124       {
74125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74126       };
74127     } catch (...) {
74128       {
74129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74130       };
74131     }
74132   }
74133
74134   jresult = (void *)result;
74135   return jresult;
74136 }
74137
74138
74139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74140   int jresult ;
74141   int result;
74142
74143   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74144   jresult = (int)result;
74145   return jresult;
74146 }
74147
74148
74149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74150   int jresult ;
74151   int result;
74152
74153   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74154   jresult = (int)result;
74155   return jresult;
74156 }
74157
74158
74159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74160   int jresult ;
74161   int result;
74162
74163   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74164   jresult = (int)result;
74165   return jresult;
74166 }
74167
74168
74169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74170   int jresult ;
74171   int result;
74172
74173   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74174   jresult = (int)result;
74175   return jresult;
74176 }
74177
74178
74179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74180   int jresult ;
74181   int result;
74182
74183   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74184   jresult = (int)result;
74185   return jresult;
74186 }
74187
74188
74189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74190   int jresult ;
74191   int result;
74192
74193   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74194   jresult = (int)result;
74195   return jresult;
74196 }
74197
74198
74199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74200   int jresult ;
74201   int result;
74202
74203   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74204   jresult = (int)result;
74205   return jresult;
74206 }
74207
74208
74209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74210   int jresult ;
74211   int result;
74212
74213   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74214   jresult = (int)result;
74215   return jresult;
74216 }
74217
74218
74219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74220   int jresult ;
74221   int result;
74222
74223   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74224   jresult = (int)result;
74225   return jresult;
74226 }
74227
74228
74229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74230   int jresult ;
74231   int result;
74232
74233   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74234   jresult = (int)result;
74235   return jresult;
74236 }
74237
74238
74239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74240   int jresult ;
74241   int result;
74242
74243   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74244   jresult = (int)result;
74245   return jresult;
74246 }
74247
74248
74249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74250   int jresult ;
74251   int result;
74252
74253   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74254   jresult = (int)result;
74255   return jresult;
74256 }
74257
74258
74259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74260   int jresult ;
74261   int result;
74262
74263   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74264   jresult = (int)result;
74265   return jresult;
74266 }
74267
74268
74269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74270   int jresult ;
74271   int result;
74272
74273   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74274   jresult = (int)result;
74275   return jresult;
74276 }
74277
74278
74279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74280   void * jresult ;
74281   Dali::Toolkit::Scrollable::Property *result = 0 ;
74282
74283   {
74284     try {
74285       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74286     } catch (std::out_of_range& e) {
74287       {
74288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74289       };
74290     } catch (std::exception& e) {
74291       {
74292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74293       };
74294     } catch (Dali::DaliException e) {
74295       {
74296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74297       };
74298     } catch (...) {
74299       {
74300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74301       };
74302     }
74303   }
74304
74305   jresult = (void *)result;
74306   return jresult;
74307 }
74308
74309
74310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74311   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74312
74313   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74314   {
74315     try {
74316       delete arg1;
74317     } catch (std::out_of_range& e) {
74318       {
74319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74320       };
74321     } catch (std::exception& e) {
74322       {
74323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74324       };
74325     } catch (Dali::DaliException e) {
74326       {
74327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74328       };
74329     } catch (...) {
74330       {
74331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74332       };
74333     }
74334   }
74335
74336 }
74337
74338
74339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74340   void * jresult ;
74341   Dali::Toolkit::Scrollable *result = 0 ;
74342
74343   {
74344     try {
74345       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74346     } catch (std::out_of_range& e) {
74347       {
74348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74349       };
74350     } catch (std::exception& e) {
74351       {
74352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74353       };
74354     } catch (Dali::DaliException e) {
74355       {
74356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74357       };
74358     } catch (...) {
74359       {
74360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74361       };
74362     }
74363   }
74364
74365   jresult = (void *)result;
74366   return jresult;
74367 }
74368
74369
74370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74371   void * jresult ;
74372   Dali::Toolkit::Scrollable *arg1 = 0 ;
74373   Dali::Toolkit::Scrollable *result = 0 ;
74374
74375   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74376   if (!arg1) {
74377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74378     return 0;
74379   }
74380   {
74381     try {
74382       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74383     } catch (std::out_of_range& e) {
74384       {
74385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74386       };
74387     } catch (std::exception& e) {
74388       {
74389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74390       };
74391     } catch (Dali::DaliException e) {
74392       {
74393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74394       };
74395     } catch (...) {
74396       {
74397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74398       };
74399     }
74400   }
74401
74402   jresult = (void *)result;
74403   return jresult;
74404 }
74405
74406
74407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74408   void * jresult ;
74409   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74410   Dali::Toolkit::Scrollable *arg2 = 0 ;
74411   Dali::Toolkit::Scrollable *result = 0 ;
74412
74413   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74414   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74415   if (!arg2) {
74416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74417     return 0;
74418   }
74419   {
74420     try {
74421       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74422     } catch (std::out_of_range& e) {
74423       {
74424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74425       };
74426     } catch (std::exception& e) {
74427       {
74428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74429       };
74430     } catch (Dali::DaliException e) {
74431       {
74432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74433       };
74434     } catch (...) {
74435       {
74436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74437       };
74438     }
74439   }
74440
74441   jresult = (void *)result;
74442   return jresult;
74443 }
74444
74445
74446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74447   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74448
74449   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74450   {
74451     try {
74452       delete arg1;
74453     } catch (std::out_of_range& e) {
74454       {
74455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74456       };
74457     } catch (std::exception& e) {
74458       {
74459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74460       };
74461     } catch (Dali::DaliException e) {
74462       {
74463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74464       };
74465     } catch (...) {
74466       {
74467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74468       };
74469     }
74470   }
74471
74472 }
74473
74474
74475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74476   void * jresult ;
74477   Dali::BaseHandle arg1 ;
74478   Dali::BaseHandle *argp1 ;
74479   Dali::Toolkit::Scrollable result;
74480
74481   argp1 = (Dali::BaseHandle *)jarg1;
74482   if (!argp1) {
74483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74484     return 0;
74485   }
74486   arg1 = *argp1;
74487   {
74488     try {
74489       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74490     } catch (std::out_of_range& e) {
74491       {
74492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74493       };
74494     } catch (std::exception& e) {
74495       {
74496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74497       };
74498     } catch (Dali::DaliException e) {
74499       {
74500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74501       };
74502     } catch (...) {
74503       {
74504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74505       };
74506     }
74507   }
74508
74509   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74510   return jresult;
74511 }
74512
74513
74514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74515   unsigned int jresult ;
74516   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74517   bool result;
74518
74519   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74520   {
74521     try {
74522       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74523     } catch (std::out_of_range& e) {
74524       {
74525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74526       };
74527     } catch (std::exception& e) {
74528       {
74529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74530       };
74531     } catch (Dali::DaliException e) {
74532       {
74533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74534       };
74535     } catch (...) {
74536       {
74537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74538       };
74539     }
74540   }
74541
74542   jresult = result;
74543   return jresult;
74544 }
74545
74546
74547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74548   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74549   bool arg2 ;
74550
74551   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74552   arg2 = jarg2 ? true : false;
74553   {
74554     try {
74555       (arg1)->SetOvershootEnabled(arg2);
74556     } catch (std::out_of_range& e) {
74557       {
74558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74559       };
74560     } catch (std::exception& e) {
74561       {
74562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74563       };
74564     } catch (Dali::DaliException e) {
74565       {
74566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74567       };
74568     } catch (...) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74571       };
74572     }
74573   }
74574
74575 }
74576
74577
74578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74579   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74580   Dali::Vector4 *arg2 = 0 ;
74581
74582   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74583   arg2 = (Dali::Vector4 *)jarg2;
74584   if (!arg2) {
74585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74586     return ;
74587   }
74588   {
74589     try {
74590       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74591     } catch (std::out_of_range& e) {
74592       {
74593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74594       };
74595     } catch (std::exception& e) {
74596       {
74597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74598       };
74599     } catch (Dali::DaliException e) {
74600       {
74601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74602       };
74603     } catch (...) {
74604       {
74605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74606       };
74607     }
74608   }
74609
74610 }
74611
74612
74613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74614   void * jresult ;
74615   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74616   Dali::Vector4 result;
74617
74618   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74619   {
74620     try {
74621       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74622     } catch (std::out_of_range& e) {
74623       {
74624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74625       };
74626     } catch (std::exception& e) {
74627       {
74628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74629       };
74630     } catch (Dali::DaliException e) {
74631       {
74632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74633       };
74634     } catch (...) {
74635       {
74636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74637       };
74638     }
74639   }
74640
74641   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74642   return jresult;
74643 }
74644
74645
74646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74647   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74648   float arg2 ;
74649
74650   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74651   arg2 = (float)jarg2;
74652   {
74653     try {
74654       (arg1)->SetOvershootAnimationSpeed(arg2);
74655     } catch (std::out_of_range& e) {
74656       {
74657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74658       };
74659     } catch (std::exception& e) {
74660       {
74661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74662       };
74663     } catch (Dali::DaliException e) {
74664       {
74665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74666       };
74667     } catch (...) {
74668       {
74669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74670       };
74671     }
74672   }
74673
74674 }
74675
74676
74677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74678   float jresult ;
74679   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74680   float result;
74681
74682   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74683   {
74684     try {
74685       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74686     } catch (std::out_of_range& e) {
74687       {
74688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74689       };
74690     } catch (std::exception& e) {
74691       {
74692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74693       };
74694     } catch (Dali::DaliException e) {
74695       {
74696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74697       };
74698     } catch (...) {
74699       {
74700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74701       };
74702     }
74703   }
74704
74705   jresult = result;
74706   return jresult;
74707 }
74708
74709
74710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74711   void * jresult ;
74712   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74713   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74714
74715   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74716   {
74717     try {
74718       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74719     } catch (std::out_of_range& e) {
74720       {
74721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74722       };
74723     } catch (std::exception& e) {
74724       {
74725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74726       };
74727     } catch (Dali::DaliException e) {
74728       {
74729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74730       };
74731     } catch (...) {
74732       {
74733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74734       };
74735     }
74736   }
74737
74738   jresult = (void *)result;
74739   return jresult;
74740 }
74741
74742
74743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74744   void * jresult ;
74745   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74746   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74747
74748   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74749   {
74750     try {
74751       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74752     } catch (std::out_of_range& e) {
74753       {
74754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74755       };
74756     } catch (std::exception& e) {
74757       {
74758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74759       };
74760     } catch (Dali::DaliException e) {
74761       {
74762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74763       };
74764     } catch (...) {
74765       {
74766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74767       };
74768     }
74769   }
74770
74771   jresult = (void *)result;
74772   return jresult;
74773 }
74774
74775
74776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74777   void * jresult ;
74778   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74779   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74780
74781   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74782   {
74783     try {
74784       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74785     } catch (std::out_of_range& e) {
74786       {
74787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74788       };
74789     } catch (std::exception& e) {
74790       {
74791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74792       };
74793     } catch (Dali::DaliException e) {
74794       {
74795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74796       };
74797     } catch (...) {
74798       {
74799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74800       };
74801     }
74802   }
74803
74804   jresult = (void *)result;
74805   return jresult;
74806 }
74807
74808
74809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74810   unsigned int jresult ;
74811   Dali::Toolkit::ControlOrientation::Type arg1 ;
74812   bool result;
74813
74814   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74815   {
74816     try {
74817       result = (bool)Dali::Toolkit::IsVertical(arg1);
74818     } catch (std::out_of_range& e) {
74819       {
74820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74821       };
74822     } catch (std::exception& e) {
74823       {
74824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74825       };
74826     } catch (Dali::DaliException e) {
74827       {
74828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74829       };
74830     } catch (...) {
74831       {
74832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74833       };
74834     }
74835   }
74836
74837   jresult = result;
74838   return jresult;
74839 }
74840
74841
74842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74843   unsigned int jresult ;
74844   Dali::Toolkit::ControlOrientation::Type arg1 ;
74845   bool result;
74846
74847   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74848   {
74849     try {
74850       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74851     } catch (std::out_of_range& e) {
74852       {
74853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74854       };
74855     } catch (std::exception& e) {
74856       {
74857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74858       };
74859     } catch (Dali::DaliException e) {
74860       {
74861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74862       };
74863     } catch (...) {
74864       {
74865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74866       };
74867     }
74868   }
74869
74870   jresult = result;
74871   return jresult;
74872 }
74873
74874
74875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74876   void * jresult ;
74877   unsigned int arg1 ;
74878   unsigned int arg2 ;
74879   Dali::Toolkit::ItemRange *result = 0 ;
74880
74881   arg1 = (unsigned int)jarg1;
74882   arg2 = (unsigned int)jarg2;
74883   {
74884     try {
74885       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74886     } catch (std::out_of_range& e) {
74887       {
74888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74889       };
74890     } catch (std::exception& e) {
74891       {
74892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74893       };
74894     } catch (Dali::DaliException e) {
74895       {
74896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74897       };
74898     } catch (...) {
74899       {
74900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74901       };
74902     }
74903   }
74904
74905   jresult = (void *)result;
74906   return jresult;
74907 }
74908
74909
74910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74911   void * jresult ;
74912   Dali::Toolkit::ItemRange *arg1 = 0 ;
74913   Dali::Toolkit::ItemRange *result = 0 ;
74914
74915   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74916   if (!arg1) {
74917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74918     return 0;
74919   }
74920   {
74921     try {
74922       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74923     } catch (std::out_of_range& e) {
74924       {
74925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74926       };
74927     } catch (std::exception& e) {
74928       {
74929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74930       };
74931     } catch (Dali::DaliException e) {
74932       {
74933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74934       };
74935     } catch (...) {
74936       {
74937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74938       };
74939     }
74940   }
74941
74942   jresult = (void *)result;
74943   return jresult;
74944 }
74945
74946
74947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74948   void * jresult ;
74949   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74950   Dali::Toolkit::ItemRange *arg2 = 0 ;
74951   Dali::Toolkit::ItemRange *result = 0 ;
74952
74953   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74954   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74955   if (!arg2) {
74956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74957     return 0;
74958   }
74959   {
74960     try {
74961       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74962     } catch (std::out_of_range& e) {
74963       {
74964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74965       };
74966     } catch (std::exception& e) {
74967       {
74968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74969       };
74970     } catch (Dali::DaliException e) {
74971       {
74972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74973       };
74974     } catch (...) {
74975       {
74976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74977       };
74978     }
74979   }
74980
74981   jresult = (void *)result;
74982   return jresult;
74983 }
74984
74985
74986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74987   unsigned int jresult ;
74988   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74989   unsigned int arg2 ;
74990   bool result;
74991
74992   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74993   arg2 = (unsigned int)jarg2;
74994   {
74995     try {
74996       result = (bool)(arg1)->Within(arg2);
74997     } catch (std::out_of_range& e) {
74998       {
74999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75000       };
75001     } catch (std::exception& e) {
75002       {
75003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75004       };
75005     } catch (Dali::DaliException e) {
75006       {
75007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75008       };
75009     } catch (...) {
75010       {
75011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75012       };
75013     }
75014   }
75015
75016   jresult = result;
75017   return jresult;
75018 }
75019
75020
75021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
75022   void * jresult ;
75023   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75024   Dali::Toolkit::ItemRange *arg2 = 0 ;
75025   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75026
75027   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75028   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75029   if (!arg2) {
75030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
75031     return 0;
75032   }
75033   {
75034     try {
75035       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
75036     } catch (std::out_of_range& e) {
75037       {
75038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75039       };
75040     } catch (std::exception& e) {
75041       {
75042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75043       };
75044     } catch (Dali::DaliException e) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75047       };
75048     } catch (...) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75051       };
75052     }
75053   }
75054
75055   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75056   return jresult;
75057 }
75058
75059
75060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
75061   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75062   unsigned int arg2 ;
75063
75064   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75065   arg2 = (unsigned int)jarg2;
75066   if (arg1) (arg1)->begin = arg2;
75067 }
75068
75069
75070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75071   unsigned int jresult ;
75072   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75073   unsigned int result;
75074
75075   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75076   result = (unsigned int) ((arg1)->begin);
75077   jresult = result;
75078   return jresult;
75079 }
75080
75081
75082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75083   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75084   unsigned int arg2 ;
75085
75086   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75087   arg2 = (unsigned int)jarg2;
75088   if (arg1) (arg1)->end = arg2;
75089 }
75090
75091
75092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75093   unsigned int jresult ;
75094   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75095   unsigned int result;
75096
75097   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75098   result = (unsigned int) ((arg1)->end);
75099   jresult = result;
75100   return jresult;
75101 }
75102
75103
75104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75105   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75106
75107   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75108   {
75109     try {
75110       delete arg1;
75111     } catch (std::out_of_range& e) {
75112       {
75113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75114       };
75115     } catch (std::exception& e) {
75116       {
75117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75118       };
75119     } catch (Dali::DaliException e) {
75120       {
75121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75122       };
75123     } catch (...) {
75124       {
75125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75126       };
75127     }
75128   }
75129
75130 }
75131
75132
75133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75134   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75135
75136   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75137   {
75138     try {
75139       delete arg1;
75140     } catch (std::out_of_range& e) {
75141       {
75142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75143       };
75144     } catch (std::exception& e) {
75145       {
75146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75147       };
75148     } catch (Dali::DaliException e) {
75149       {
75150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75151       };
75152     } catch (...) {
75153       {
75154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75155       };
75156     }
75157   }
75158
75159 }
75160
75161
75162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75163   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75164   Dali::Toolkit::ControlOrientation::Type arg2 ;
75165
75166   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75167   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75168   {
75169     try {
75170       (arg1)->SetOrientation(arg2);
75171     } catch (std::out_of_range& e) {
75172       {
75173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (std::exception& e) {
75176       {
75177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75178       };
75179     } catch (Dali::DaliException e) {
75180       {
75181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75182       };
75183     } catch (...) {
75184       {
75185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75186       };
75187     }
75188   }
75189
75190 }
75191
75192
75193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75194   int jresult ;
75195   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75196   Dali::Toolkit::ControlOrientation::Type result;
75197
75198   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75199   {
75200     try {
75201       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75202     } catch (std::out_of_range& e) {
75203       {
75204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75205       };
75206     } catch (std::exception& e) {
75207       {
75208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75209       };
75210     } catch (Dali::DaliException e) {
75211       {
75212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75213       };
75214     } catch (...) {
75215       {
75216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75217       };
75218     }
75219   }
75220
75221   jresult = (int)result;
75222   return jresult;
75223 }
75224
75225
75226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75227   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75228   Dali::Property::Map *arg2 = 0 ;
75229
75230   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75231   arg2 = (Dali::Property::Map *)jarg2;
75232   if (!arg2) {
75233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75234     return ;
75235   }
75236   {
75237     try {
75238       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75239     } catch (std::out_of_range& e) {
75240       {
75241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75242       };
75243     } catch (std::exception& e) {
75244       {
75245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75246       };
75247     } catch (Dali::DaliException e) {
75248       {
75249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75250       };
75251     } catch (...) {
75252       {
75253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75254       };
75255     }
75256   }
75257
75258 }
75259
75260
75261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75262   void * jresult ;
75263   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75264   Dali::Property::Map result;
75265
75266   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75267   {
75268     try {
75269       result = (arg1)->GetLayoutProperties();
75270     } catch (std::out_of_range& e) {
75271       {
75272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75273       };
75274     } catch (std::exception& e) {
75275       {
75276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75277       };
75278     } catch (Dali::DaliException e) {
75279       {
75280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75281       };
75282     } catch (...) {
75283       {
75284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75285       };
75286     }
75287   }
75288
75289   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75290   return jresult;
75291 }
75292
75293
75294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75295   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75296   unsigned int arg2 ;
75297   Dali::Vector3 *arg3 = 0 ;
75298   Dali::Vector3 *arg4 = 0 ;
75299
75300   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75301   arg2 = (unsigned int)jarg2;
75302   arg3 = (Dali::Vector3 *)jarg3;
75303   if (!arg3) {
75304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75305     return ;
75306   }
75307   arg4 = (Dali::Vector3 *)jarg4;
75308   if (!arg4) {
75309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75310     return ;
75311   }
75312   {
75313     try {
75314       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75315     } catch (std::out_of_range& e) {
75316       {
75317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75318       };
75319     } catch (std::exception& e) {
75320       {
75321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75322       };
75323     } catch (Dali::DaliException e) {
75324       {
75325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75326       };
75327     } catch (...) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75330       };
75331     }
75332   }
75333
75334 }
75335
75336
75337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75338   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75339   Dali::Vector3 *arg2 = 0 ;
75340
75341   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75342   arg2 = (Dali::Vector3 *)jarg2;
75343   if (!arg2) {
75344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75345     return ;
75346   }
75347   {
75348     try {
75349       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75350     } catch (std::out_of_range& e) {
75351       {
75352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75353       };
75354     } catch (std::exception& e) {
75355       {
75356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75357       };
75358     } catch (Dali::DaliException e) {
75359       {
75360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75361       };
75362     } catch (...) {
75363       {
75364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75365       };
75366     }
75367   }
75368
75369 }
75370
75371
75372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75373   float jresult ;
75374   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75375   unsigned int arg2 ;
75376   Dali::Vector3 arg3 ;
75377   Dali::Vector3 *argp3 ;
75378   float result;
75379
75380   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75381   arg2 = (unsigned int)jarg2;
75382   argp3 = (Dali::Vector3 *)jarg3;
75383   if (!argp3) {
75384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75385     return 0;
75386   }
75387   arg3 = *argp3;
75388   {
75389     try {
75390       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75391     } catch (std::out_of_range& e) {
75392       {
75393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75394       };
75395     } catch (std::exception& e) {
75396       {
75397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75398       };
75399     } catch (Dali::DaliException e) {
75400       {
75401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75402       };
75403     } catch (...) {
75404       {
75405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75406       };
75407     }
75408   }
75409
75410   jresult = result;
75411   return jresult;
75412 }
75413
75414
75415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75416   float jresult ;
75417   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75418   float arg2 ;
75419   float result;
75420
75421   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75422   arg2 = (float)jarg2;
75423   {
75424     try {
75425       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75426     } catch (std::out_of_range& e) {
75427       {
75428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75429       };
75430     } catch (std::exception& e) {
75431       {
75432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75433       };
75434     } catch (Dali::DaliException e) {
75435       {
75436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75437       };
75438     } catch (...) {
75439       {
75440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75441       };
75442     }
75443   }
75444
75445   jresult = result;
75446   return jresult;
75447 }
75448
75449
75450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75451   float jresult ;
75452   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75453   unsigned int arg2 ;
75454   float result;
75455
75456   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75457   arg2 = (unsigned int)jarg2;
75458   {
75459     try {
75460       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75461     } catch (std::out_of_range& e) {
75462       {
75463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75464       };
75465     } catch (std::exception& e) {
75466       {
75467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75468       };
75469     } catch (Dali::DaliException e) {
75470       {
75471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75472       };
75473     } catch (...) {
75474       {
75475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75476       };
75477     }
75478   }
75479
75480   jresult = result;
75481   return jresult;
75482 }
75483
75484
75485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75486   void * jresult ;
75487   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75488   float arg2 ;
75489   Dali::Vector3 arg3 ;
75490   Dali::Vector3 *argp3 ;
75491   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75492
75493   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75494   arg2 = (float)jarg2;
75495   argp3 = (Dali::Vector3 *)jarg3;
75496   if (!argp3) {
75497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75498     return 0;
75499   }
75500   arg3 = *argp3;
75501   {
75502     try {
75503       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75504     } catch (std::out_of_range& e) {
75505       {
75506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75507       };
75508     } catch (std::exception& e) {
75509       {
75510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75511       };
75512     } catch (Dali::DaliException e) {
75513       {
75514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75515       };
75516     } catch (...) {
75517       {
75518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75519       };
75520     }
75521   }
75522
75523   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75524   return jresult;
75525 }
75526
75527
75528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75529   float jresult ;
75530   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75531   int arg2 ;
75532   float arg3 ;
75533   Dali::Vector3 *arg4 = 0 ;
75534   float result;
75535
75536   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75537   arg2 = (int)jarg2;
75538   arg3 = (float)jarg3;
75539   arg4 = (Dali::Vector3 *)jarg4;
75540   if (!arg4) {
75541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75542     return 0;
75543   }
75544   {
75545     try {
75546       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75547     } catch (std::out_of_range& e) {
75548       {
75549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75550       };
75551     } catch (std::exception& e) {
75552       {
75553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75554       };
75555     } catch (Dali::DaliException e) {
75556       {
75557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75558       };
75559     } catch (...) {
75560       {
75561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75562       };
75563     }
75564   }
75565
75566   jresult = result;
75567   return jresult;
75568 }
75569
75570
75571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75572   unsigned int jresult ;
75573   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75574   Dali::Vector3 arg2 ;
75575   Dali::Vector3 *argp2 ;
75576   unsigned int result;
75577
75578   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75579   argp2 = (Dali::Vector3 *)jarg2;
75580   if (!argp2) {
75581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75582     return 0;
75583   }
75584   arg2 = *argp2;
75585   {
75586     try {
75587       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75588     } catch (std::out_of_range& e) {
75589       {
75590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75591       };
75592     } catch (std::exception& e) {
75593       {
75594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75595       };
75596     } catch (Dali::DaliException e) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75599       };
75600     } catch (...) {
75601       {
75602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75603       };
75604     }
75605   }
75606
75607   jresult = result;
75608   return jresult;
75609 }
75610
75611
75612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75613   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75614   unsigned int arg2 ;
75615   Dali::Vector3 *arg3 = 0 ;
75616   Dali::Vector3 *arg4 = 0 ;
75617
75618   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75619   arg2 = (unsigned int)jarg2;
75620   arg3 = (Dali::Vector3 *)jarg3;
75621   if (!arg3) {
75622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75623     return ;
75624   }
75625   arg4 = (Dali::Vector3 *)jarg4;
75626   if (!arg4) {
75627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75628     return ;
75629   }
75630   {
75631     try {
75632       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75633     } catch (std::out_of_range& e) {
75634       {
75635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75636       };
75637     } catch (std::exception& e) {
75638       {
75639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75640       };
75641     } catch (Dali::DaliException e) {
75642       {
75643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75644       };
75645     } catch (...) {
75646       {
75647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75648       };
75649     }
75650   }
75651
75652 }
75653
75654
75655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75656   void * jresult ;
75657   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75658   Dali::Degree result;
75659
75660   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75661   {
75662     try {
75663       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75664     } catch (std::out_of_range& e) {
75665       {
75666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75667       };
75668     } catch (std::exception& e) {
75669       {
75670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75671       };
75672     } catch (Dali::DaliException e) {
75673       {
75674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75675       };
75676     } catch (...) {
75677       {
75678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75679       };
75680     }
75681   }
75682
75683   jresult = new Dali::Degree((const Dali::Degree &)result);
75684   return jresult;
75685 }
75686
75687
75688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75689   float jresult ;
75690   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75691   float result;
75692
75693   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75694   {
75695     try {
75696       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75697     } catch (std::out_of_range& e) {
75698       {
75699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75700       };
75701     } catch (std::exception& e) {
75702       {
75703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75704       };
75705     } catch (Dali::DaliException e) {
75706       {
75707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75708       };
75709     } catch (...) {
75710       {
75711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75712       };
75713     }
75714   }
75715
75716   jresult = result;
75717   return jresult;
75718 }
75719
75720
75721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75722   float jresult ;
75723   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75724   float result;
75725
75726   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75727   {
75728     try {
75729       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75730     } catch (std::out_of_range& e) {
75731       {
75732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75733       };
75734     } catch (std::exception& e) {
75735       {
75736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75737       };
75738     } catch (Dali::DaliException e) {
75739       {
75740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75741       };
75742     } catch (...) {
75743       {
75744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75745       };
75746     }
75747   }
75748
75749   jresult = result;
75750   return jresult;
75751 }
75752
75753
75754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75755   float jresult ;
75756   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75757   float result;
75758
75759   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75760   {
75761     try {
75762       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75763     } catch (std::out_of_range& e) {
75764       {
75765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75766       };
75767     } catch (std::exception& e) {
75768       {
75769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75770       };
75771     } catch (Dali::DaliException e) {
75772       {
75773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75774       };
75775     } catch (...) {
75776       {
75777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75778       };
75779     }
75780   }
75781
75782   jresult = result;
75783   return jresult;
75784 }
75785
75786
75787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75788   int jresult ;
75789   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75790   int arg2 ;
75791   int arg3 ;
75792   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75793   bool arg5 ;
75794   int result;
75795
75796   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75797   arg2 = (int)jarg2;
75798   arg3 = (int)jarg3;
75799   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75800   arg5 = jarg5 ? true : false;
75801   {
75802     try {
75803       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75804     } catch (std::out_of_range& e) {
75805       {
75806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75807       };
75808     } catch (std::exception& e) {
75809       {
75810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75811       };
75812     } catch (Dali::DaliException e) {
75813       {
75814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75815       };
75816     } catch (...) {
75817       {
75818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75819       };
75820     }
75821   }
75822
75823   jresult = result;
75824   return jresult;
75825 }
75826
75827
75828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75829   float jresult ;
75830   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75831   float result;
75832
75833   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75834   {
75835     try {
75836       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75837     } catch (std::out_of_range& e) {
75838       {
75839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75840       };
75841     } catch (std::exception& e) {
75842       {
75843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75844       };
75845     } catch (Dali::DaliException e) {
75846       {
75847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75848       };
75849     } catch (...) {
75850       {
75851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75852       };
75853     }
75854   }
75855
75856   jresult = result;
75857   return jresult;
75858 }
75859
75860
75861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75862   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75863   Dali::Actor *arg2 = 0 ;
75864   int arg3 ;
75865   Dali::Vector3 *arg4 = 0 ;
75866   Dali::Actor *arg5 = 0 ;
75867
75868   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75869   arg2 = (Dali::Actor *)jarg2;
75870   if (!arg2) {
75871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75872     return ;
75873   }
75874   arg3 = (int)jarg3;
75875   arg4 = (Dali::Vector3 *)jarg4;
75876   if (!arg4) {
75877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75878     return ;
75879   }
75880   arg5 = (Dali::Actor *)jarg5;
75881   if (!arg5) {
75882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75883     return ;
75884   }
75885   {
75886     try {
75887       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75888     } catch (std::out_of_range& e) {
75889       {
75890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75891       };
75892     } catch (std::exception& e) {
75893       {
75894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75895       };
75896     } catch (Dali::DaliException e) {
75897       {
75898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75899       };
75900     } catch (...) {
75901       {
75902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75903       };
75904     }
75905   }
75906
75907 }
75908
75909
75910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75911   void * jresult ;
75912   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75913   int arg2 ;
75914   float arg3 ;
75915   Dali::Vector3 *arg4 = 0 ;
75916   Dali::Vector3 result;
75917
75918   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75919   arg2 = (int)jarg2;
75920   arg3 = (float)jarg3;
75921   arg4 = (Dali::Vector3 *)jarg4;
75922   if (!arg4) {
75923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75924     return 0;
75925   }
75926   {
75927     try {
75928       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75929     } catch (std::out_of_range& e) {
75930       {
75931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75932       };
75933     } catch (std::exception& e) {
75934       {
75935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75936       };
75937     } catch (Dali::DaliException e) {
75938       {
75939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75940       };
75941     } catch (...) {
75942       {
75943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75944       };
75945     }
75946   }
75947
75948   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75949   return jresult;
75950 }
75951
75952
75953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75954   void * jresult ;
75955   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75956   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75957
75958   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75959   {
75960     try {
75961       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75962     } catch (std::out_of_range& e) {
75963       {
75964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75965       };
75966     } catch (std::exception& e) {
75967       {
75968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75969       };
75970     } catch (Dali::DaliException e) {
75971       {
75972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75973       };
75974     } catch (...) {
75975       {
75976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75977       };
75978     }
75979   }
75980
75981   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75982   return jresult;
75983 }
75984
75985
75986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75987   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75988
75989   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75990   {
75991     try {
75992       delete arg1;
75993     } catch (std::out_of_range& e) {
75994       {
75995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75996       };
75997     } catch (std::exception& e) {
75998       {
75999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76000       };
76001     } catch (Dali::DaliException e) {
76002       {
76003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76004       };
76005     } catch (...) {
76006       {
76007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76008       };
76009     }
76010   }
76011
76012 }
76013
76014
76015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
76016   unsigned int jresult ;
76017   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76018   unsigned int result;
76019
76020   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76021   {
76022     try {
76023       result = (unsigned int)(arg1)->GetNumberOfItems();
76024     } catch (std::out_of_range& e) {
76025       {
76026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76027       };
76028     } catch (std::exception& e) {
76029       {
76030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76031       };
76032     } catch (Dali::DaliException e) {
76033       {
76034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76035       };
76036     } catch (...) {
76037       {
76038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76039       };
76040     }
76041   }
76042
76043   jresult = result;
76044   return jresult;
76045 }
76046
76047
76048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
76049   void * jresult ;
76050   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76051   unsigned int arg2 ;
76052   Dali::Actor result;
76053
76054   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76055   arg2 = (unsigned int)jarg2;
76056   {
76057     try {
76058       result = (arg1)->NewItem(arg2);
76059     } catch (std::out_of_range& e) {
76060       {
76061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76062       };
76063     } catch (std::exception& e) {
76064       {
76065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76066       };
76067     } catch (Dali::DaliException e) {
76068       {
76069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76070       };
76071     } catch (...) {
76072       {
76073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76074       };
76075     }
76076   }
76077
76078   jresult = new Dali::Actor((const Dali::Actor &)result);
76079   return jresult;
76080 }
76081
76082
76083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76084   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76085   unsigned int arg2 ;
76086   Dali::Actor arg3 ;
76087   Dali::Actor *argp3 ;
76088
76089   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76090   arg2 = (unsigned int)jarg2;
76091   argp3 = (Dali::Actor *)jarg3;
76092   if (!argp3) {
76093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76094     return ;
76095   }
76096   arg3 = *argp3;
76097   {
76098     try {
76099       (arg1)->ItemReleased(arg2,arg3);
76100     } catch (std::out_of_range& e) {
76101       {
76102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76103       };
76104     } catch (std::exception& e) {
76105       {
76106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76107       };
76108     } catch (Dali::DaliException e) {
76109       {
76110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76111       };
76112     } catch (...) {
76113       {
76114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76115       };
76116     }
76117   }
76118
76119 }
76120
76121
76122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76123   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76124   unsigned int arg2 ;
76125   Dali::Actor arg3 ;
76126   Dali::Actor *argp3 ;
76127
76128   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76129   arg2 = (unsigned int)jarg2;
76130   argp3 = (Dali::Actor *)jarg3;
76131   if (!argp3) {
76132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76133     return ;
76134   }
76135   arg3 = *argp3;
76136   {
76137     try {
76138       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76139     } catch (std::out_of_range& e) {
76140       {
76141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76142       };
76143     } catch (std::exception& e) {
76144       {
76145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76146       };
76147     } catch (Dali::DaliException e) {
76148       {
76149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76150       };
76151     } catch (...) {
76152       {
76153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76154       };
76155     }
76156   }
76157
76158 }
76159
76160
76161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76162   void * jresult ;
76163   Dali::Toolkit::ItemFactory *result = 0 ;
76164
76165   {
76166     try {
76167       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76168     } catch (std::out_of_range& e) {
76169       {
76170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76171       };
76172     } catch (std::exception& e) {
76173       {
76174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76175       };
76176     } catch (Dali::DaliException e) {
76177       {
76178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76179       };
76180     } catch (...) {
76181       {
76182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76183       };
76184     }
76185   }
76186
76187   jresult = (void *)result;
76188   return jresult;
76189 }
76190
76191
76192 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) {
76193   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76194   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76195   if (director) {
76196     director->swig_connect_director(callback0, callback1, callback2);
76197   }
76198 }
76199
76200
76201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76202   int jresult ;
76203   int result;
76204
76205   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76206   jresult = (int)result;
76207   return jresult;
76208 }
76209
76210
76211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76212   int jresult ;
76213   int result;
76214
76215   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76216   jresult = (int)result;
76217   return jresult;
76218 }
76219
76220
76221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76222   int jresult ;
76223   int result;
76224
76225   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76226   jresult = (int)result;
76227   return jresult;
76228 }
76229
76230
76231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76232   int jresult ;
76233   int result;
76234
76235   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76236   jresult = (int)result;
76237   return jresult;
76238 }
76239
76240
76241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76242   int jresult ;
76243   int result;
76244
76245   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76246   jresult = (int)result;
76247   return jresult;
76248 }
76249
76250
76251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76252   int jresult ;
76253   int result;
76254
76255   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76256   jresult = (int)result;
76257   return jresult;
76258 }
76259
76260
76261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76262   int jresult ;
76263   int result;
76264
76265   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76266   jresult = (int)result;
76267   return jresult;
76268 }
76269
76270
76271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76272   int jresult ;
76273   int result;
76274
76275   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76276   jresult = (int)result;
76277   return jresult;
76278 }
76279
76280
76281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76282   int jresult ;
76283   int result;
76284
76285   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76286   jresult = (int)result;
76287   return jresult;
76288 }
76289
76290
76291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76292   int jresult ;
76293   int result;
76294
76295   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76296   jresult = (int)result;
76297   return jresult;
76298 }
76299
76300
76301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76302   int jresult ;
76303   int result;
76304
76305   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76306   jresult = (int)result;
76307   return jresult;
76308 }
76309
76310
76311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76312   void * jresult ;
76313   Dali::Toolkit::ItemView::Property *result = 0 ;
76314
76315   {
76316     try {
76317       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76318     } catch (std::out_of_range& e) {
76319       {
76320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76321       };
76322     } catch (std::exception& e) {
76323       {
76324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76325       };
76326     } catch (Dali::DaliException e) {
76327       {
76328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76329       };
76330     } catch (...) {
76331       {
76332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76333       };
76334     }
76335   }
76336
76337   jresult = (void *)result;
76338   return jresult;
76339 }
76340
76341
76342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76343   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76344
76345   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76346   {
76347     try {
76348       delete arg1;
76349     } catch (std::out_of_range& e) {
76350       {
76351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76352       };
76353     } catch (std::exception& e) {
76354       {
76355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76356       };
76357     } catch (Dali::DaliException e) {
76358       {
76359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76360       };
76361     } catch (...) {
76362       {
76363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76364       };
76365     }
76366   }
76367
76368 }
76369
76370
76371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76372   void * jresult ;
76373   Dali::Toolkit::ItemView *result = 0 ;
76374
76375   {
76376     try {
76377       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76378     } catch (std::out_of_range& e) {
76379       {
76380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76381       };
76382     } catch (std::exception& e) {
76383       {
76384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76385       };
76386     } catch (Dali::DaliException e) {
76387       {
76388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76389       };
76390     } catch (...) {
76391       {
76392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76393       };
76394     }
76395   }
76396
76397   jresult = (void *)result;
76398   return jresult;
76399 }
76400
76401
76402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76403   void * jresult ;
76404   Dali::Toolkit::ItemView *arg1 = 0 ;
76405   Dali::Toolkit::ItemView *result = 0 ;
76406
76407   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76408   if (!arg1) {
76409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76410     return 0;
76411   }
76412   {
76413     try {
76414       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76415     } catch (std::out_of_range& e) {
76416       {
76417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76418       };
76419     } catch (std::exception& e) {
76420       {
76421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76422       };
76423     } catch (Dali::DaliException e) {
76424       {
76425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76426       };
76427     } catch (...) {
76428       {
76429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76430       };
76431     }
76432   }
76433
76434   jresult = (void *)result;
76435   return jresult;
76436 }
76437
76438
76439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76440   void * jresult ;
76441   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76442   Dali::Toolkit::ItemView *arg2 = 0 ;
76443   Dali::Toolkit::ItemView *result = 0 ;
76444
76445   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76446   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76447   if (!arg2) {
76448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76449     return 0;
76450   }
76451   {
76452     try {
76453       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76454     } catch (std::out_of_range& e) {
76455       {
76456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76457       };
76458     } catch (std::exception& e) {
76459       {
76460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76461       };
76462     } catch (Dali::DaliException e) {
76463       {
76464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76465       };
76466     } catch (...) {
76467       {
76468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76469       };
76470     }
76471   }
76472
76473   jresult = (void *)result;
76474   return jresult;
76475 }
76476
76477
76478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76479   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76480
76481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76482   {
76483     try {
76484       delete arg1;
76485     } catch (std::out_of_range& e) {
76486       {
76487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76488       };
76489     } catch (std::exception& e) {
76490       {
76491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76492       };
76493     } catch (Dali::DaliException e) {
76494       {
76495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76496       };
76497     } catch (...) {
76498       {
76499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76500       };
76501     }
76502   }
76503
76504 }
76505
76506
76507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76508   void * jresult ;
76509   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76510   Dali::Toolkit::ItemView result;
76511
76512   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76513   if (!arg1) {
76514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76515     return 0;
76516   }
76517   {
76518     try {
76519       result = Dali::Toolkit::ItemView::New(*arg1);
76520     } catch (std::out_of_range& e) {
76521       {
76522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76523       };
76524     } catch (std::exception& e) {
76525       {
76526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76527       };
76528     } catch (Dali::DaliException e) {
76529       {
76530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76531       };
76532     } catch (...) {
76533       {
76534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76535       };
76536     }
76537   }
76538
76539   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76540   return jresult;
76541 }
76542
76543
76544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76545   void * jresult ;
76546   Dali::BaseHandle arg1 ;
76547   Dali::BaseHandle *argp1 ;
76548   Dali::Toolkit::ItemView result;
76549
76550   argp1 = (Dali::BaseHandle *)jarg1;
76551   if (!argp1) {
76552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76553     return 0;
76554   }
76555   arg1 = *argp1;
76556   {
76557     try {
76558       result = Dali::Toolkit::ItemView::DownCast(arg1);
76559     } catch (std::out_of_range& e) {
76560       {
76561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76562       };
76563     } catch (std::exception& e) {
76564       {
76565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76566       };
76567     } catch (Dali::DaliException e) {
76568       {
76569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76570       };
76571     } catch (...) {
76572       {
76573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76574       };
76575     }
76576   }
76577
76578   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76579   return jresult;
76580 }
76581
76582
76583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76584   unsigned int jresult ;
76585   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76586   unsigned int result;
76587
76588   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76589   {
76590     try {
76591       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76592     } catch (std::out_of_range& e) {
76593       {
76594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76595       };
76596     } catch (std::exception& e) {
76597       {
76598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76599       };
76600     } catch (Dali::DaliException e) {
76601       {
76602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76603       };
76604     } catch (...) {
76605       {
76606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76607       };
76608     }
76609   }
76610
76611   jresult = result;
76612   return jresult;
76613 }
76614
76615
76616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76617   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76618   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76619
76620   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76621   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76622   if (!arg2) {
76623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76624     return ;
76625   }
76626   {
76627     try {
76628       (arg1)->AddLayout(*arg2);
76629     } catch (std::out_of_range& e) {
76630       {
76631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76632       };
76633     } catch (std::exception& e) {
76634       {
76635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76636       };
76637     } catch (Dali::DaliException e) {
76638       {
76639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76640       };
76641     } catch (...) {
76642       {
76643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76644       };
76645     }
76646   }
76647
76648 }
76649
76650
76651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76652   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76653   unsigned int arg2 ;
76654
76655   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76656   arg2 = (unsigned int)jarg2;
76657   {
76658     try {
76659       (arg1)->RemoveLayout(arg2);
76660     } catch (std::out_of_range& e) {
76661       {
76662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76663       };
76664     } catch (std::exception& e) {
76665       {
76666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76667       };
76668     } catch (Dali::DaliException e) {
76669       {
76670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76671       };
76672     } catch (...) {
76673       {
76674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76675       };
76676     }
76677   }
76678
76679 }
76680
76681
76682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76683   void * jresult ;
76684   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76685   unsigned int arg2 ;
76686   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76687
76688   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76689   arg2 = (unsigned int)jarg2;
76690   {
76691     try {
76692       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76693     } catch (std::out_of_range& e) {
76694       {
76695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76696       };
76697     } catch (std::exception& e) {
76698       {
76699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76700       };
76701     } catch (Dali::DaliException e) {
76702       {
76703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76704       };
76705     } catch (...) {
76706       {
76707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76708       };
76709     }
76710   }
76711
76712   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76713   return jresult;
76714 }
76715
76716
76717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76718   void * jresult ;
76719   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76720   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76721
76722   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76723   {
76724     try {
76725       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76726     } catch (std::out_of_range& e) {
76727       {
76728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76729       };
76730     } catch (std::exception& e) {
76731       {
76732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76733       };
76734     } catch (Dali::DaliException e) {
76735       {
76736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76737       };
76738     } catch (...) {
76739       {
76740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76741       };
76742     }
76743   }
76744
76745   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76746   return jresult;
76747 }
76748
76749
76750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76751   float jresult ;
76752   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76753   Dali::Toolkit::ItemId arg2 ;
76754   float result;
76755
76756   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76757   arg2 = (Dali::Toolkit::ItemId)jarg2;
76758   {
76759     try {
76760       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76761     } catch (std::out_of_range& e) {
76762       {
76763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76764       };
76765     } catch (std::exception& e) {
76766       {
76767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76768       };
76769     } catch (Dali::DaliException e) {
76770       {
76771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76772       };
76773     } catch (...) {
76774       {
76775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76776       };
76777     }
76778   }
76779
76780   jresult = result;
76781   return jresult;
76782 }
76783
76784
76785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76786   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76787   unsigned int arg2 ;
76788   Dali::Vector3 arg3 ;
76789   float arg4 ;
76790   Dali::Vector3 *argp3 ;
76791
76792   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76793   arg2 = (unsigned int)jarg2;
76794   argp3 = (Dali::Vector3 *)jarg3;
76795   if (!argp3) {
76796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76797     return ;
76798   }
76799   arg3 = *argp3;
76800   arg4 = (float)jarg4;
76801   {
76802     try {
76803       (arg1)->ActivateLayout(arg2,arg3,arg4);
76804     } catch (std::out_of_range& e) {
76805       {
76806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76807       };
76808     } catch (std::exception& e) {
76809       {
76810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76811       };
76812     } catch (Dali::DaliException e) {
76813       {
76814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76815       };
76816     } catch (...) {
76817       {
76818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76819       };
76820     }
76821   }
76822
76823 }
76824
76825
76826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76828
76829   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76830   {
76831     try {
76832       (arg1)->DeactivateCurrentLayout();
76833     } catch (std::out_of_range& e) {
76834       {
76835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76836       };
76837     } catch (std::exception& e) {
76838       {
76839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76840       };
76841     } catch (Dali::DaliException e) {
76842       {
76843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76844       };
76845     } catch (...) {
76846       {
76847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76848       };
76849     }
76850   }
76851
76852 }
76853
76854
76855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76856   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76857   float arg2 ;
76858
76859   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76860   arg2 = (float)jarg2;
76861   {
76862     try {
76863       (arg1)->SetMinimumSwipeSpeed(arg2);
76864     } catch (std::out_of_range& e) {
76865       {
76866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76867       };
76868     } catch (std::exception& e) {
76869       {
76870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76871       };
76872     } catch (Dali::DaliException e) {
76873       {
76874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76875       };
76876     } catch (...) {
76877       {
76878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76879       };
76880     }
76881   }
76882
76883 }
76884
76885
76886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76887   float jresult ;
76888   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76889   float result;
76890
76891   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76892   {
76893     try {
76894       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76895     } catch (std::out_of_range& e) {
76896       {
76897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76898       };
76899     } catch (std::exception& e) {
76900       {
76901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76902       };
76903     } catch (Dali::DaliException e) {
76904       {
76905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76906       };
76907     } catch (...) {
76908       {
76909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76910       };
76911     }
76912   }
76913
76914   jresult = result;
76915   return jresult;
76916 }
76917
76918
76919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76920   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76921   float arg2 ;
76922
76923   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76924   arg2 = (float)jarg2;
76925   {
76926     try {
76927       (arg1)->SetMinimumSwipeDistance(arg2);
76928     } catch (std::out_of_range& e) {
76929       {
76930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76931       };
76932     } catch (std::exception& e) {
76933       {
76934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76935       };
76936     } catch (Dali::DaliException e) {
76937       {
76938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76939       };
76940     } catch (...) {
76941       {
76942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76943       };
76944     }
76945   }
76946
76947 }
76948
76949
76950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76951   float jresult ;
76952   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76953   float result;
76954
76955   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76956   {
76957     try {
76958       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76959     } catch (std::out_of_range& e) {
76960       {
76961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76962       };
76963     } catch (std::exception& e) {
76964       {
76965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76966       };
76967     } catch (Dali::DaliException e) {
76968       {
76969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76970       };
76971     } catch (...) {
76972       {
76973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76974       };
76975     }
76976   }
76977
76978   jresult = result;
76979   return jresult;
76980 }
76981
76982
76983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76984   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76985   float arg2 ;
76986
76987   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76988   arg2 = (float)jarg2;
76989   {
76990     try {
76991       (arg1)->SetWheelScrollDistanceStep(arg2);
76992     } catch (std::out_of_range& e) {
76993       {
76994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76995       };
76996     } catch (std::exception& e) {
76997       {
76998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76999       };
77000     } catch (Dali::DaliException e) {
77001       {
77002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77003       };
77004     } catch (...) {
77005       {
77006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77007       };
77008     }
77009   }
77010
77011 }
77012
77013
77014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
77015   float jresult ;
77016   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77017   float result;
77018
77019   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77020   {
77021     try {
77022       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
77023     } catch (std::out_of_range& e) {
77024       {
77025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77026       };
77027     } catch (std::exception& e) {
77028       {
77029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77030       };
77031     } catch (Dali::DaliException e) {
77032       {
77033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77034       };
77035     } catch (...) {
77036       {
77037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77038       };
77039     }
77040   }
77041
77042   jresult = result;
77043   return jresult;
77044 }
77045
77046
77047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
77048   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77049   bool arg2 ;
77050
77051   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77052   arg2 = jarg2 ? true : false;
77053   {
77054     try {
77055       (arg1)->SetAnchoring(arg2);
77056     } catch (std::out_of_range& e) {
77057       {
77058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77059       };
77060     } catch (std::exception& e) {
77061       {
77062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77063       };
77064     } catch (Dali::DaliException e) {
77065       {
77066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77067       };
77068     } catch (...) {
77069       {
77070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77071       };
77072     }
77073   }
77074
77075 }
77076
77077 //// ========================= end of part 3 =============================
77078
77079 //// ========================== start part 4 ===============================
77080
77081
77082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77083   unsigned int jresult ;
77084   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77085   bool result;
77086
77087   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77088   {
77089     try {
77090       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77091     } catch (std::out_of_range& e) {
77092       {
77093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77094       };
77095     } catch (std::exception& e) {
77096       {
77097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77098       };
77099     } catch (Dali::DaliException e) {
77100       {
77101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77102       };
77103     } catch (...) {
77104       {
77105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77106       };
77107     }
77108   }
77109
77110   jresult = result;
77111   return jresult;
77112 }
77113
77114
77115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77116   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77117   float arg2 ;
77118
77119   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77120   arg2 = (float)jarg2;
77121   {
77122     try {
77123       (arg1)->SetAnchoringDuration(arg2);
77124     } catch (std::out_of_range& e) {
77125       {
77126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77127       };
77128     } catch (std::exception& e) {
77129       {
77130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77131       };
77132     } catch (Dali::DaliException e) {
77133       {
77134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77135       };
77136     } catch (...) {
77137       {
77138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77139       };
77140     }
77141   }
77142
77143 }
77144
77145
77146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77147   float jresult ;
77148   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77149   float result;
77150
77151   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77152   {
77153     try {
77154       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77155     } catch (std::out_of_range& e) {
77156       {
77157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77158       };
77159     } catch (std::exception& e) {
77160       {
77161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77162       };
77163     } catch (Dali::DaliException e) {
77164       {
77165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77166       };
77167     } catch (...) {
77168       {
77169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77170       };
77171     }
77172   }
77173
77174   jresult = result;
77175   return jresult;
77176 }
77177
77178
77179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77180   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77181   Dali::Toolkit::ItemId arg2 ;
77182   float arg3 ;
77183
77184   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77185   arg2 = (Dali::Toolkit::ItemId)jarg2;
77186   arg3 = (float)jarg3;
77187   {
77188     try {
77189       (arg1)->ScrollToItem(arg2,arg3);
77190     } catch (std::out_of_range& e) {
77191       {
77192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77193       };
77194     } catch (std::exception& e) {
77195       {
77196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77197       };
77198     } catch (Dali::DaliException e) {
77199       {
77200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77201       };
77202     } catch (...) {
77203       {
77204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77205       };
77206     }
77207   }
77208
77209 }
77210
77211
77212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77213   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77214   float arg2 ;
77215
77216   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77217   arg2 = (float)jarg2;
77218   {
77219     try {
77220       (arg1)->SetRefreshInterval(arg2);
77221     } catch (std::out_of_range& e) {
77222       {
77223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77224       };
77225     } catch (std::exception& e) {
77226       {
77227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77228       };
77229     } catch (Dali::DaliException e) {
77230       {
77231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77232       };
77233     } catch (...) {
77234       {
77235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77236       };
77237     }
77238   }
77239
77240 }
77241
77242
77243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77244   float jresult ;
77245   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77246   float result;
77247
77248   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77249   {
77250     try {
77251       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77252     } catch (std::out_of_range& e) {
77253       {
77254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77255       };
77256     } catch (std::exception& e) {
77257       {
77258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77259       };
77260     } catch (Dali::DaliException e) {
77261       {
77262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77263       };
77264     } catch (...) {
77265       {
77266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77267       };
77268     }
77269   }
77270
77271   jresult = result;
77272   return jresult;
77273 }
77274
77275
77276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77277   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77278
77279   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77280   {
77281     try {
77282       (arg1)->Refresh();
77283     } catch (std::out_of_range& e) {
77284       {
77285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77286       };
77287     } catch (std::exception& e) {
77288       {
77289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77290       };
77291     } catch (Dali::DaliException e) {
77292       {
77293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77294       };
77295     } catch (...) {
77296       {
77297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77298       };
77299     }
77300   }
77301
77302 }
77303
77304
77305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77306   void * jresult ;
77307   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77308   Dali::Toolkit::ItemId arg2 ;
77309   Dali::Actor result;
77310
77311   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77312   arg2 = (Dali::Toolkit::ItemId)jarg2;
77313   {
77314     try {
77315       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77316     } catch (std::out_of_range& e) {
77317       {
77318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77319       };
77320     } catch (std::exception& e) {
77321       {
77322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77323       };
77324     } catch (Dali::DaliException e) {
77325       {
77326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77327       };
77328     } catch (...) {
77329       {
77330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77331       };
77332     }
77333   }
77334
77335   jresult = new Dali::Actor((const Dali::Actor &)result);
77336   return jresult;
77337 }
77338
77339
77340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77341   unsigned int jresult ;
77342   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77343   Dali::Actor arg2 ;
77344   Dali::Actor *argp2 ;
77345   Dali::Toolkit::ItemId result;
77346
77347   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77348   argp2 = (Dali::Actor *)jarg2;
77349   if (!argp2) {
77350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77351     return 0;
77352   }
77353   arg2 = *argp2;
77354   {
77355     try {
77356       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77357     } catch (std::out_of_range& e) {
77358       {
77359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77360       };
77361     } catch (std::exception& e) {
77362       {
77363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77364       };
77365     } catch (Dali::DaliException e) {
77366       {
77367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77368       };
77369     } catch (...) {
77370       {
77371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77372       };
77373     }
77374   }
77375
77376   jresult = result;
77377   return jresult;
77378 }
77379
77380
77381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77382   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77383   Dali::Toolkit::Item arg2 ;
77384   float arg3 ;
77385   Dali::Toolkit::Item *argp2 ;
77386
77387   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77388   argp2 = (Dali::Toolkit::Item *)jarg2;
77389   if (!argp2) {
77390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77391     return ;
77392   }
77393   arg2 = *argp2;
77394   arg3 = (float)jarg3;
77395   {
77396     try {
77397       (arg1)->InsertItem(arg2,arg3);
77398     } catch (std::out_of_range& e) {
77399       {
77400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77401       };
77402     } catch (std::exception& e) {
77403       {
77404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77405       };
77406     } catch (Dali::DaliException e) {
77407       {
77408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77409       };
77410     } catch (...) {
77411       {
77412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77413       };
77414     }
77415   }
77416
77417 }
77418
77419
77420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77421   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77422   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77423   float arg3 ;
77424
77425   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77426   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77427   if (!arg2) {
77428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77429     return ;
77430   }
77431   arg3 = (float)jarg3;
77432   {
77433     try {
77434       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77435     } catch (std::out_of_range& e) {
77436       {
77437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77438       };
77439     } catch (std::exception& e) {
77440       {
77441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77442       };
77443     } catch (Dali::DaliException e) {
77444       {
77445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77446       };
77447     } catch (...) {
77448       {
77449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77450       };
77451     }
77452   }
77453
77454 }
77455
77456
77457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77458   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77459   Dali::Toolkit::ItemId arg2 ;
77460   float arg3 ;
77461
77462   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77463   arg2 = (Dali::Toolkit::ItemId)jarg2;
77464   arg3 = (float)jarg3;
77465   {
77466     try {
77467       (arg1)->RemoveItem(arg2,arg3);
77468     } catch (std::out_of_range& e) {
77469       {
77470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77471       };
77472     } catch (std::exception& e) {
77473       {
77474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77475       };
77476     } catch (Dali::DaliException e) {
77477       {
77478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77479       };
77480     } catch (...) {
77481       {
77482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77483       };
77484     }
77485   }
77486
77487 }
77488
77489
77490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77491   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77492   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77493   float arg3 ;
77494
77495   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77496   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77497   if (!arg2) {
77498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77499     return ;
77500   }
77501   arg3 = (float)jarg3;
77502   {
77503     try {
77504       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77505     } catch (std::out_of_range& e) {
77506       {
77507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77508       };
77509     } catch (std::exception& e) {
77510       {
77511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77512       };
77513     } catch (Dali::DaliException e) {
77514       {
77515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77516       };
77517     } catch (...) {
77518       {
77519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77520       };
77521     }
77522   }
77523
77524 }
77525
77526
77527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77528   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77529   Dali::Toolkit::Item arg2 ;
77530   float arg3 ;
77531   Dali::Toolkit::Item *argp2 ;
77532
77533   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77534   argp2 = (Dali::Toolkit::Item *)jarg2;
77535   if (!argp2) {
77536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77537     return ;
77538   }
77539   arg2 = *argp2;
77540   arg3 = (float)jarg3;
77541   {
77542     try {
77543       (arg1)->ReplaceItem(arg2,arg3);
77544     } catch (std::out_of_range& e) {
77545       {
77546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77547       };
77548     } catch (std::exception& e) {
77549       {
77550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77551       };
77552     } catch (Dali::DaliException e) {
77553       {
77554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77555       };
77556     } catch (...) {
77557       {
77558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77559       };
77560     }
77561   }
77562
77563 }
77564
77565
77566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77567   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77568   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77569   float arg3 ;
77570
77571   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77572   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77573   if (!arg2) {
77574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77575     return ;
77576   }
77577   arg3 = (float)jarg3;
77578   {
77579     try {
77580       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77581     } catch (std::out_of_range& e) {
77582       {
77583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77584       };
77585     } catch (std::exception& e) {
77586       {
77587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77588       };
77589     } catch (Dali::DaliException e) {
77590       {
77591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77592       };
77593     } catch (...) {
77594       {
77595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77596       };
77597     }
77598   }
77599
77600 }
77601
77602
77603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77604   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77605   Dali::Vector3 *arg2 = 0 ;
77606
77607   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77608   arg2 = (Dali::Vector3 *)jarg2;
77609   if (!arg2) {
77610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77611     return ;
77612   }
77613   {
77614     try {
77615       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77616     } catch (std::out_of_range& e) {
77617       {
77618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77619       };
77620     } catch (std::exception& e) {
77621       {
77622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77623       };
77624     } catch (Dali::DaliException e) {
77625       {
77626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77627       };
77628     } catch (...) {
77629       {
77630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77631       };
77632     }
77633   }
77634
77635 }
77636
77637
77638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77639   void * jresult ;
77640   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77641   Dali::Vector3 result;
77642
77643   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77644   {
77645     try {
77646       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77647     } catch (std::out_of_range& e) {
77648       {
77649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77650       };
77651     } catch (std::exception& e) {
77652       {
77653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77654       };
77655     } catch (Dali::DaliException e) {
77656       {
77657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77658       };
77659     } catch (...) {
77660       {
77661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77662       };
77663     }
77664   }
77665
77666   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77667   return jresult;
77668 }
77669
77670
77671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77673   Dali::Vector3 *arg2 = 0 ;
77674
77675   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77676   arg2 = (Dali::Vector3 *)jarg2;
77677   if (!arg2) {
77678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77679     return ;
77680   }
77681   {
77682     try {
77683       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77684     } catch (std::out_of_range& e) {
77685       {
77686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77687       };
77688     } catch (std::exception& e) {
77689       {
77690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77691       };
77692     } catch (Dali::DaliException e) {
77693       {
77694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77695       };
77696     } catch (...) {
77697       {
77698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77699       };
77700     }
77701   }
77702
77703 }
77704
77705
77706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77707   void * jresult ;
77708   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77709   Dali::Vector3 result;
77710
77711   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77712   {
77713     try {
77714       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77715     } catch (std::out_of_range& e) {
77716       {
77717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77718       };
77719     } catch (std::exception& e) {
77720       {
77721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77722       };
77723     } catch (Dali::DaliException e) {
77724       {
77725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77726       };
77727     } catch (...) {
77728       {
77729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77730       };
77731     }
77732   }
77733
77734   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77735   return jresult;
77736 }
77737
77738
77739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77740   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77741   Dali::Toolkit::ItemRange *arg2 = 0 ;
77742
77743   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77744   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77745   if (!arg2) {
77746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77747     return ;
77748   }
77749   {
77750     try {
77751       (arg1)->GetItemsRange(*arg2);
77752     } catch (std::out_of_range& e) {
77753       {
77754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77755       };
77756     } catch (std::exception& e) {
77757       {
77758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77759       };
77760     } catch (Dali::DaliException e) {
77761       {
77762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77763       };
77764     } catch (...) {
77765       {
77766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77767       };
77768     }
77769   }
77770
77771 }
77772
77773
77774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77775   void * jresult ;
77776   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77777   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77778
77779   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77780   {
77781     try {
77782       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77783     } catch (std::out_of_range& e) {
77784       {
77785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77786       };
77787     } catch (std::exception& e) {
77788       {
77789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77790       };
77791     } catch (Dali::DaliException e) {
77792       {
77793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77794       };
77795     } catch (...) {
77796       {
77797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77798       };
77799     }
77800   }
77801
77802   jresult = (void *)result;
77803   return jresult;
77804 }
77805
77806
77807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77808   Dali::Vector3 *arg1 = 0 ;
77809   PropertyInputContainer *arg2 = 0 ;
77810
77811   arg1 = (Dali::Vector3 *)jarg1;
77812   if (!arg1) {
77813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77814     return ;
77815   }
77816   arg2 = (PropertyInputContainer *)jarg2;
77817   if (!arg2) {
77818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77819     return ;
77820   }
77821   {
77822     try {
77823       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77824     } catch (std::out_of_range& e) {
77825       {
77826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77827       };
77828     } catch (std::exception& e) {
77829       {
77830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77831       };
77832     } catch (Dali::DaliException e) {
77833       {
77834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77835       };
77836     } catch (...) {
77837       {
77838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77839       };
77840     }
77841   }
77842
77843 }
77844
77845
77846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77847   Dali::Vector3 *arg1 = 0 ;
77848   PropertyInputContainer *arg2 = 0 ;
77849
77850   arg1 = (Dali::Vector3 *)jarg1;
77851   if (!arg1) {
77852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77853     return ;
77854   }
77855   arg2 = (PropertyInputContainer *)jarg2;
77856   if (!arg2) {
77857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77858     return ;
77859   }
77860   {
77861     try {
77862       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77863     } catch (std::out_of_range& e) {
77864       {
77865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77866       };
77867     } catch (std::exception& e) {
77868       {
77869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77870       };
77871     } catch (Dali::DaliException e) {
77872       {
77873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77874       };
77875     } catch (...) {
77876       {
77877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77878       };
77879     }
77880   }
77881
77882 }
77883
77884
77885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77886   void * jresult ;
77887   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77888
77889   {
77890     try {
77891       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77892     } catch (std::out_of_range& e) {
77893       {
77894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77895       };
77896     } catch (std::exception& e) {
77897       {
77898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77899       };
77900     } catch (Dali::DaliException e) {
77901       {
77902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77903       };
77904     } catch (...) {
77905       {
77906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77907       };
77908     }
77909   }
77910
77911   jresult = (void *)result;
77912   return jresult;
77913 }
77914
77915
77916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77917   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77918
77919   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77920   {
77921     try {
77922       delete arg1;
77923     } catch (std::out_of_range& e) {
77924       {
77925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77926       };
77927     } catch (std::exception& e) {
77928       {
77929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77930       };
77931     } catch (Dali::DaliException e) {
77932       {
77933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77934       };
77935     } catch (...) {
77936       {
77937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77938       };
77939     }
77940   }
77941
77942 }
77943
77944
77945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77946   void * jresult ;
77947   Dali::Path arg1 ;
77948   Dali::Vector3 *arg2 = 0 ;
77949   Dali::Property::Index arg3 ;
77950   Dali::Vector3 *arg4 = 0 ;
77951   unsigned int arg5 ;
77952   Dali::Path *argp1 ;
77953   Dali::Toolkit::ScrollViewPagePathEffect result;
77954
77955   argp1 = (Dali::Path *)jarg1;
77956   if (!argp1) {
77957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77958     return 0;
77959   }
77960   arg1 = *argp1;
77961   arg2 = (Dali::Vector3 *)jarg2;
77962   if (!arg2) {
77963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77964     return 0;
77965   }
77966   arg3 = (Dali::Property::Index)jarg3;
77967   arg4 = (Dali::Vector3 *)jarg4;
77968   if (!arg4) {
77969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77970     return 0;
77971   }
77972   arg5 = (unsigned int)jarg5;
77973   {
77974     try {
77975       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77976     } catch (std::out_of_range& e) {
77977       {
77978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77979       };
77980     } catch (std::exception& e) {
77981       {
77982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77983       };
77984     } catch (Dali::DaliException e) {
77985       {
77986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77987       };
77988     } catch (...) {
77989       {
77990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77991       };
77992     }
77993   }
77994
77995   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77996   return jresult;
77997 }
77998
77999
78000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
78001   void * jresult ;
78002   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
78003
78004   {
78005     try {
78006       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
78007     } catch (std::out_of_range& e) {
78008       {
78009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78010       };
78011     } catch (std::exception& e) {
78012       {
78013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78014       };
78015     } catch (Dali::DaliException e) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78018       };
78019     } catch (...) {
78020       {
78021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78022       };
78023     }
78024   }
78025
78026   jresult = (void *)result;
78027   return jresult;
78028 }
78029
78030
78031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
78032   void * jresult ;
78033   Dali::BaseHandle arg1 ;
78034   Dali::BaseHandle *argp1 ;
78035   Dali::Toolkit::ScrollViewPagePathEffect result;
78036
78037   argp1 = (Dali::BaseHandle *)jarg1;
78038   if (!argp1) {
78039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78040     return 0;
78041   }
78042   arg1 = *argp1;
78043   {
78044     try {
78045       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
78046     } catch (std::out_of_range& e) {
78047       {
78048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78049       };
78050     } catch (std::exception& e) {
78051       {
78052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78053       };
78054     } catch (Dali::DaliException e) {
78055       {
78056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78057       };
78058     } catch (...) {
78059       {
78060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78061       };
78062     }
78063   }
78064
78065   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78066   return jresult;
78067 }
78068
78069
78070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78071   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78072   Dali::Actor arg2 ;
78073   unsigned int arg3 ;
78074   Dali::Actor *argp2 ;
78075
78076   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78077   argp2 = (Dali::Actor *)jarg2;
78078   if (!argp2) {
78079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78080     return ;
78081   }
78082   arg2 = *argp2;
78083   arg3 = (unsigned int)jarg3;
78084   {
78085     try {
78086       (arg1)->ApplyToPage(arg2,arg3);
78087     } catch (std::out_of_range& e) {
78088       {
78089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78090       };
78091     } catch (std::exception& e) {
78092       {
78093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78094       };
78095     } catch (Dali::DaliException e) {
78096       {
78097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78098       };
78099     } catch (...) {
78100       {
78101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78102       };
78103     }
78104   }
78105
78106 }
78107
78108
78109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78110   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78111
78112   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78113   {
78114     try {
78115       delete arg1;
78116     } catch (std::out_of_range& e) {
78117       {
78118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78119       };
78120     } catch (std::exception& e) {
78121       {
78122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78123       };
78124     } catch (Dali::DaliException e) {
78125       {
78126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78127       };
78128     } catch (...) {
78129       {
78130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78131       };
78132     }
78133   }
78134
78135 }
78136
78137
78138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78139   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78140   Dali::Toolkit::ClampState arg2 ;
78141
78142   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78143   arg2 = (Dali::Toolkit::ClampState)jarg2;
78144   if (arg1) (arg1)->x = arg2;
78145 }
78146
78147
78148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78149   int jresult ;
78150   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78151   Dali::Toolkit::ClampState result;
78152
78153   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78154   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78155   jresult = (int)result;
78156   return jresult;
78157 }
78158
78159
78160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78161   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78162   Dali::Toolkit::ClampState arg2 ;
78163
78164   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78165   arg2 = (Dali::Toolkit::ClampState)jarg2;
78166   if (arg1) (arg1)->y = arg2;
78167 }
78168
78169
78170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78171   int jresult ;
78172   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78173   Dali::Toolkit::ClampState result;
78174
78175   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78176   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78177   jresult = (int)result;
78178   return jresult;
78179 }
78180
78181
78182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78183   void * jresult ;
78184   Dali::Toolkit::ClampState2D *result = 0 ;
78185
78186   {
78187     try {
78188       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78189     } catch (std::out_of_range& e) {
78190       {
78191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78192       };
78193     } catch (std::exception& e) {
78194       {
78195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78196       };
78197     } catch (Dali::DaliException e) {
78198       {
78199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78200       };
78201     } catch (...) {
78202       {
78203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78204       };
78205     }
78206   }
78207
78208   jresult = (void *)result;
78209   return jresult;
78210 }
78211
78212
78213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78214   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78215
78216   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78217   {
78218     try {
78219       delete arg1;
78220     } catch (std::out_of_range& e) {
78221       {
78222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78223       };
78224     } catch (std::exception& e) {
78225       {
78226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78227       };
78228     } catch (Dali::DaliException e) {
78229       {
78230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78231       };
78232     } catch (...) {
78233       {
78234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78235       };
78236     }
78237   }
78238
78239 }
78240
78241
78242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78243   void * jresult ;
78244   float arg1 ;
78245   float arg2 ;
78246   bool arg3 ;
78247   Dali::Toolkit::RulerDomain *result = 0 ;
78248
78249   arg1 = (float)jarg1;
78250   arg2 = (float)jarg2;
78251   arg3 = jarg3 ? true : false;
78252   {
78253     try {
78254       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78255     } catch (std::out_of_range& e) {
78256       {
78257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78258       };
78259     } catch (std::exception& e) {
78260       {
78261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78262       };
78263     } catch (Dali::DaliException e) {
78264       {
78265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78266       };
78267     } catch (...) {
78268       {
78269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78270       };
78271     }
78272   }
78273
78274   jresult = (void *)result;
78275   return jresult;
78276 }
78277
78278
78279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78280   void * jresult ;
78281   float arg1 ;
78282   float arg2 ;
78283   Dali::Toolkit::RulerDomain *result = 0 ;
78284
78285   arg1 = (float)jarg1;
78286   arg2 = (float)jarg2;
78287   {
78288     try {
78289       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78290     } catch (std::out_of_range& e) {
78291       {
78292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78293       };
78294     } catch (std::exception& e) {
78295       {
78296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78297       };
78298     } catch (Dali::DaliException e) {
78299       {
78300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78301       };
78302     } catch (...) {
78303       {
78304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78305       };
78306     }
78307   }
78308
78309   jresult = (void *)result;
78310   return jresult;
78311 }
78312
78313
78314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78315   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78316   float arg2 ;
78317
78318   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78319   arg2 = (float)jarg2;
78320   if (arg1) (arg1)->min = arg2;
78321 }
78322
78323
78324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78325   float jresult ;
78326   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78327   float result;
78328
78329   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78330   result = (float) ((arg1)->min);
78331   jresult = result;
78332   return jresult;
78333 }
78334
78335
78336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78337   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78338   float arg2 ;
78339
78340   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78341   arg2 = (float)jarg2;
78342   if (arg1) (arg1)->max = arg2;
78343 }
78344
78345
78346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78347   float jresult ;
78348   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78349   float result;
78350
78351   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78352   result = (float) ((arg1)->max);
78353   jresult = result;
78354   return jresult;
78355 }
78356
78357
78358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78359   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78360   bool arg2 ;
78361
78362   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78363   arg2 = jarg2 ? true : false;
78364   if (arg1) (arg1)->enabled = arg2;
78365 }
78366
78367
78368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78369   unsigned int jresult ;
78370   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78371   bool result;
78372
78373   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78374   result = (bool) ((arg1)->enabled);
78375   jresult = result;
78376   return jresult;
78377 }
78378
78379
78380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78381   float jresult ;
78382   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78383   float arg2 ;
78384   float arg3 ;
78385   float arg4 ;
78386   float result;
78387
78388   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78389   arg2 = (float)jarg2;
78390   arg3 = (float)jarg3;
78391   arg4 = (float)jarg4;
78392   {
78393     try {
78394       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78395     } catch (std::out_of_range& e) {
78396       {
78397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78398       };
78399     } catch (std::exception& e) {
78400       {
78401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78402       };
78403     } catch (Dali::DaliException e) {
78404       {
78405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78406       };
78407     } catch (...) {
78408       {
78409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78410       };
78411     }
78412   }
78413
78414   jresult = result;
78415   return jresult;
78416 }
78417
78418
78419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78420   float jresult ;
78421   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78422   float arg2 ;
78423   float arg3 ;
78424   float result;
78425
78426   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78427   arg2 = (float)jarg2;
78428   arg3 = (float)jarg3;
78429   {
78430     try {
78431       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78432     } catch (std::out_of_range& e) {
78433       {
78434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78435       };
78436     } catch (std::exception& e) {
78437       {
78438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78439       };
78440     } catch (Dali::DaliException e) {
78441       {
78442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78443       };
78444     } catch (...) {
78445       {
78446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78447       };
78448     }
78449   }
78450
78451   jresult = result;
78452   return jresult;
78453 }
78454
78455
78456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78457   float jresult ;
78458   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78459   float arg2 ;
78460   float result;
78461
78462   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78463   arg2 = (float)jarg2;
78464   {
78465     try {
78466       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78467     } catch (std::out_of_range& e) {
78468       {
78469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78470       };
78471     } catch (std::exception& e) {
78472       {
78473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78474       };
78475     } catch (Dali::DaliException e) {
78476       {
78477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78478       };
78479     } catch (...) {
78480       {
78481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78482       };
78483     }
78484   }
78485
78486   jresult = result;
78487   return jresult;
78488 }
78489
78490
78491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78492   float jresult ;
78493   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78494   float arg2 ;
78495   float arg3 ;
78496   float arg4 ;
78497   Dali::Toolkit::ClampState *arg5 = 0 ;
78498   float result;
78499
78500   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78501   arg2 = (float)jarg2;
78502   arg3 = (float)jarg3;
78503   arg4 = (float)jarg4;
78504   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78505   if (!arg5) {
78506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78507     return 0;
78508   }
78509   {
78510     try {
78511       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78512     } catch (std::out_of_range& e) {
78513       {
78514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78515       };
78516     } catch (std::exception& e) {
78517       {
78518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78519       };
78520     } catch (Dali::DaliException e) {
78521       {
78522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78523       };
78524     } catch (...) {
78525       {
78526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78527       };
78528     }
78529   }
78530
78531   jresult = result;
78532   return jresult;
78533 }
78534
78535
78536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78537   float jresult ;
78538   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78539   float result;
78540
78541   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78542   {
78543     try {
78544       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78545     } catch (std::out_of_range& e) {
78546       {
78547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78548       };
78549     } catch (std::exception& e) {
78550       {
78551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78552       };
78553     } catch (Dali::DaliException e) {
78554       {
78555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78556       };
78557     } catch (...) {
78558       {
78559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78560       };
78561     }
78562   }
78563
78564   jresult = result;
78565   return jresult;
78566 }
78567
78568
78569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78570   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78571
78572   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78573   {
78574     try {
78575       delete arg1;
78576     } catch (std::out_of_range& e) {
78577       {
78578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78579       };
78580     } catch (std::exception& e) {
78581       {
78582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78583       };
78584     } catch (Dali::DaliException e) {
78585       {
78586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78587       };
78588     } catch (...) {
78589       {
78590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78591       };
78592     }
78593   }
78594
78595 }
78596
78597
78598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78599   float jresult ;
78600   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78601   float arg2 ;
78602   float arg3 ;
78603   float result;
78604
78605   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78606   arg2 = (float)jarg2;
78607   arg3 = (float)jarg3;
78608   {
78609     try {
78610       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78611     } catch (std::out_of_range& e) {
78612       {
78613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78614       };
78615     } catch (std::exception& e) {
78616       {
78617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78618       };
78619     } catch (Dali::DaliException e) {
78620       {
78621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78622       };
78623     } catch (...) {
78624       {
78625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78626       };
78627     }
78628   }
78629
78630   jresult = result;
78631   return jresult;
78632 }
78633
78634
78635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78636   float jresult ;
78637   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78638   float arg2 ;
78639   float result;
78640
78641   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78642   arg2 = (float)jarg2;
78643   {
78644     try {
78645       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78646     } catch (std::out_of_range& e) {
78647       {
78648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78649       };
78650     } catch (std::exception& e) {
78651       {
78652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78653       };
78654     } catch (Dali::DaliException e) {
78655       {
78656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78657       };
78658     } catch (...) {
78659       {
78660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78661       };
78662     }
78663   }
78664
78665   jresult = result;
78666   return jresult;
78667 }
78668
78669
78670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78671   float jresult ;
78672   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78673   unsigned int arg2 ;
78674   unsigned int *arg3 = 0 ;
78675   bool arg4 ;
78676   float result;
78677
78678   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78679   arg2 = (unsigned int)jarg2;
78680   arg3 = (unsigned int *)jarg3;
78681   arg4 = jarg4 ? true : false;
78682   {
78683     try {
78684       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78685     } catch (std::out_of_range& e) {
78686       {
78687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78688       };
78689     } catch (std::exception& e) {
78690       {
78691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78692       };
78693     } catch (Dali::DaliException e) {
78694       {
78695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78696       };
78697     } catch (...) {
78698       {
78699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78700       };
78701     }
78702   }
78703
78704   jresult = result;
78705   return jresult;
78706 }
78707
78708
78709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78710   unsigned int jresult ;
78711   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78712   float arg2 ;
78713   bool arg3 ;
78714   unsigned int result;
78715
78716   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78717   arg2 = (float)jarg2;
78718   arg3 = jarg3 ? true : false;
78719   {
78720     try {
78721       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78722     } catch (std::out_of_range& e) {
78723       {
78724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78725       };
78726     } catch (std::exception& e) {
78727       {
78728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78729       };
78730     } catch (Dali::DaliException e) {
78731       {
78732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78733       };
78734     } catch (...) {
78735       {
78736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78737       };
78738     }
78739   }
78740
78741   jresult = result;
78742   return jresult;
78743 }
78744
78745
78746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78747   unsigned int jresult ;
78748   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78749   unsigned int result;
78750
78751   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78752   {
78753     try {
78754       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78755     } catch (std::out_of_range& e) {
78756       {
78757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78758       };
78759     } catch (std::exception& e) {
78760       {
78761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78762       };
78763     } catch (Dali::DaliException e) {
78764       {
78765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78766       };
78767     } catch (...) {
78768       {
78769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78770       };
78771     }
78772   }
78773
78774   jresult = result;
78775   return jresult;
78776 }
78777
78778
78779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78780   int jresult ;
78781   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78782   Dali::Toolkit::Ruler::RulerType result;
78783
78784   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78785   {
78786     try {
78787       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78788     } catch (std::out_of_range& e) {
78789       {
78790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78791       };
78792     } catch (std::exception& e) {
78793       {
78794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78795       };
78796     } catch (Dali::DaliException e) {
78797       {
78798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78799       };
78800     } catch (...) {
78801       {
78802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78803       };
78804     }
78805   }
78806
78807   jresult = (int)result;
78808   return jresult;
78809 }
78810
78811
78812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78813   unsigned int jresult ;
78814   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78815   bool result;
78816
78817   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78818   {
78819     try {
78820       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78821     } catch (std::out_of_range& e) {
78822       {
78823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78824       };
78825     } catch (std::exception& e) {
78826       {
78827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78828       };
78829     } catch (Dali::DaliException e) {
78830       {
78831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78832       };
78833     } catch (...) {
78834       {
78835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78836       };
78837     }
78838   }
78839
78840   jresult = result;
78841   return jresult;
78842 }
78843
78844
78845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78846   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78847
78848   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78849   {
78850     try {
78851       (arg1)->Enable();
78852     } catch (std::out_of_range& e) {
78853       {
78854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78855       };
78856     } catch (std::exception& e) {
78857       {
78858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78859       };
78860     } catch (Dali::DaliException e) {
78861       {
78862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78863       };
78864     } catch (...) {
78865       {
78866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78867       };
78868     }
78869   }
78870
78871 }
78872
78873
78874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78875   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78876
78877   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78878   {
78879     try {
78880       (arg1)->Disable();
78881     } catch (std::out_of_range& e) {
78882       {
78883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78884       };
78885     } catch (std::exception& e) {
78886       {
78887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78888       };
78889     } catch (Dali::DaliException e) {
78890       {
78891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78892       };
78893     } catch (...) {
78894       {
78895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78896       };
78897     }
78898   }
78899
78900 }
78901
78902
78903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78904   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78905   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78906   Dali::Toolkit::RulerDomain *argp2 ;
78907
78908   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78909   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78910   if (!argp2) {
78911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78912     return ;
78913   }
78914   arg2 = *argp2;
78915   {
78916     try {
78917       (arg1)->SetDomain(arg2);
78918     } catch (std::out_of_range& e) {
78919       {
78920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78921       };
78922     } catch (std::exception& e) {
78923       {
78924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78925       };
78926     } catch (Dali::DaliException e) {
78927       {
78928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78929       };
78930     } catch (...) {
78931       {
78932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78933       };
78934     }
78935   }
78936
78937 }
78938
78939
78940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78941   void * jresult ;
78942   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78943   Dali::Toolkit::RulerDomain *result = 0 ;
78944
78945   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78946   {
78947     try {
78948       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78949     } catch (std::out_of_range& e) {
78950       {
78951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78952       };
78953     } catch (std::exception& e) {
78954       {
78955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78956       };
78957     } catch (Dali::DaliException e) {
78958       {
78959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78960       };
78961     } catch (...) {
78962       {
78963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78964       };
78965     }
78966   }
78967
78968   jresult = (void *)result;
78969   return jresult;
78970 }
78971
78972
78973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78974   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78975
78976   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78977   {
78978     try {
78979       (arg1)->DisableDomain();
78980     } catch (std::out_of_range& e) {
78981       {
78982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78983       };
78984     } catch (std::exception& e) {
78985       {
78986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78987       };
78988     } catch (Dali::DaliException e) {
78989       {
78990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78991       };
78992     } catch (...) {
78993       {
78994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78995       };
78996     }
78997   }
78998
78999 }
79000
79001
79002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
79003   float jresult ;
79004   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79005   float arg2 ;
79006   float arg3 ;
79007   float arg4 ;
79008   float result;
79009
79010   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79011   arg2 = (float)jarg2;
79012   arg3 = (float)jarg3;
79013   arg4 = (float)jarg4;
79014   {
79015     try {
79016       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
79017     } catch (std::out_of_range& e) {
79018       {
79019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79020       };
79021     } catch (std::exception& e) {
79022       {
79023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79024       };
79025     } catch (Dali::DaliException e) {
79026       {
79027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79028       };
79029     } catch (...) {
79030       {
79031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79032       };
79033     }
79034   }
79035
79036   jresult = result;
79037   return jresult;
79038 }
79039
79040
79041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
79042   float jresult ;
79043   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79044   float arg2 ;
79045   float arg3 ;
79046   float result;
79047
79048   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79049   arg2 = (float)jarg2;
79050   arg3 = (float)jarg3;
79051   {
79052     try {
79053       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
79054     } catch (std::out_of_range& e) {
79055       {
79056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79057       };
79058     } catch (std::exception& e) {
79059       {
79060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79061       };
79062     } catch (Dali::DaliException e) {
79063       {
79064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79065       };
79066     } catch (...) {
79067       {
79068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79069       };
79070     }
79071   }
79072
79073   jresult = result;
79074   return jresult;
79075 }
79076
79077
79078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79079   float jresult ;
79080   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79081   float arg2 ;
79082   float result;
79083
79084   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79085   arg2 = (float)jarg2;
79086   {
79087     try {
79088       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79089     } catch (std::out_of_range& e) {
79090       {
79091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79092       };
79093     } catch (std::exception& e) {
79094       {
79095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79096       };
79097     } catch (Dali::DaliException e) {
79098       {
79099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79100       };
79101     } catch (...) {
79102       {
79103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79104       };
79105     }
79106   }
79107
79108   jresult = result;
79109   return jresult;
79110 }
79111
79112
79113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79114   float jresult ;
79115   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79116   float arg2 ;
79117   float arg3 ;
79118   float arg4 ;
79119   Dali::Toolkit::ClampState *arg5 = 0 ;
79120   float result;
79121
79122   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79123   arg2 = (float)jarg2;
79124   arg3 = (float)jarg3;
79125   arg4 = (float)jarg4;
79126   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79127   if (!arg5) {
79128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79129     return 0;
79130   }
79131   {
79132     try {
79133       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79134     } catch (std::out_of_range& e) {
79135       {
79136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79137       };
79138     } catch (std::exception& e) {
79139       {
79140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79141       };
79142     } catch (Dali::DaliException e) {
79143       {
79144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79145       };
79146     } catch (...) {
79147       {
79148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79149       };
79150     }
79151   }
79152
79153   jresult = result;
79154   return jresult;
79155 }
79156
79157
79158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79159   float jresult ;
79160   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79161   float arg2 ;
79162   float arg3 ;
79163   float arg4 ;
79164   float arg5 ;
79165   float result;
79166
79167   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79168   arg2 = (float)jarg2;
79169   arg3 = (float)jarg3;
79170   arg4 = (float)jarg4;
79171   arg5 = (float)jarg5;
79172   {
79173     try {
79174       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79175     } catch (std::out_of_range& e) {
79176       {
79177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79178       };
79179     } catch (std::exception& e) {
79180       {
79181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79182       };
79183     } catch (Dali::DaliException e) {
79184       {
79185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79186       };
79187     } catch (...) {
79188       {
79189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79190       };
79191     }
79192   }
79193
79194   jresult = result;
79195   return jresult;
79196 }
79197
79198
79199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79200   float jresult ;
79201   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79202   float arg2 ;
79203   float arg3 ;
79204   float arg4 ;
79205   float result;
79206
79207   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79208   arg2 = (float)jarg2;
79209   arg3 = (float)jarg3;
79210   arg4 = (float)jarg4;
79211   {
79212     try {
79213       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79214     } catch (std::out_of_range& e) {
79215       {
79216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79217       };
79218     } catch (std::exception& e) {
79219       {
79220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79221       };
79222     } catch (Dali::DaliException e) {
79223       {
79224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79225       };
79226     } catch (...) {
79227       {
79228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79229       };
79230     }
79231   }
79232
79233   jresult = result;
79234   return jresult;
79235 }
79236
79237
79238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79239   float jresult ;
79240   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79241   float arg2 ;
79242   float arg3 ;
79243   float result;
79244
79245   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79246   arg2 = (float)jarg2;
79247   arg3 = (float)jarg3;
79248   {
79249     try {
79250       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79251     } catch (std::out_of_range& e) {
79252       {
79253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79254       };
79255     } catch (std::exception& e) {
79256       {
79257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79258       };
79259     } catch (Dali::DaliException e) {
79260       {
79261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79262       };
79263     } catch (...) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79266       };
79267     }
79268   }
79269
79270   jresult = result;
79271   return jresult;
79272 }
79273
79274
79275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79276   float jresult ;
79277   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79278   float arg2 ;
79279   float result;
79280
79281   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79282   arg2 = (float)jarg2;
79283   {
79284     try {
79285       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79286     } catch (std::out_of_range& e) {
79287       {
79288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79289       };
79290     } catch (std::exception& e) {
79291       {
79292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79293       };
79294     } catch (Dali::DaliException e) {
79295       {
79296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79297       };
79298     } catch (...) {
79299       {
79300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79301       };
79302     }
79303   }
79304
79305   jresult = result;
79306   return jresult;
79307 }
79308
79309
79310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79311   float jresult ;
79312   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79313   float arg2 ;
79314   float arg3 ;
79315   float arg4 ;
79316   float arg5 ;
79317   Dali::Toolkit::ClampState *arg6 = 0 ;
79318   float result;
79319
79320   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79321   arg2 = (float)jarg2;
79322   arg3 = (float)jarg3;
79323   arg4 = (float)jarg4;
79324   arg5 = (float)jarg5;
79325   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79326   if (!arg6) {
79327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79328     return 0;
79329   }
79330   {
79331     try {
79332       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79333     } catch (std::out_of_range& e) {
79334       {
79335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79336       };
79337     } catch (std::exception& e) {
79338       {
79339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79340       };
79341     } catch (Dali::DaliException e) {
79342       {
79343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79344       };
79345     } catch (...) {
79346       {
79347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79348       };
79349     }
79350   }
79351
79352   jresult = result;
79353   return jresult;
79354 }
79355
79356
79357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79358   void * jresult ;
79359   Dali::Toolkit::DefaultRuler *result = 0 ;
79360
79361   {
79362     try {
79363       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79364     } catch (std::out_of_range& e) {
79365       {
79366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79367       };
79368     } catch (std::exception& e) {
79369       {
79370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79371       };
79372     } catch (Dali::DaliException e) {
79373       {
79374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79375       };
79376     } catch (...) {
79377       {
79378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79379       };
79380     }
79381   }
79382
79383   jresult = (void *)result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79389   float jresult ;
79390   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79391   float arg2 ;
79392   float arg3 ;
79393   float result;
79394
79395   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79396   arg2 = (float)jarg2;
79397   arg3 = (float)jarg3;
79398   {
79399     try {
79400       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79401     } catch (std::out_of_range& e) {
79402       {
79403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79404       };
79405     } catch (std::exception& e) {
79406       {
79407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79408       };
79409     } catch (Dali::DaliException e) {
79410       {
79411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79412       };
79413     } catch (...) {
79414       {
79415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79416       };
79417     }
79418   }
79419
79420   jresult = result;
79421   return jresult;
79422 }
79423
79424
79425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79426   float jresult ;
79427   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79428   unsigned int arg2 ;
79429   unsigned int *arg3 = 0 ;
79430   bool arg4 ;
79431   float result;
79432
79433   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79434   arg2 = (unsigned int)jarg2;
79435   arg3 = (unsigned int *)jarg3;
79436   arg4 = jarg4 ? true : false;
79437   {
79438     try {
79439       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79440     } catch (std::out_of_range& e) {
79441       {
79442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79443       };
79444     } catch (std::exception& e) {
79445       {
79446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79447       };
79448     } catch (Dali::DaliException e) {
79449       {
79450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79451       };
79452     } catch (...) {
79453       {
79454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79455       };
79456     }
79457   }
79458
79459   jresult = result;
79460   return jresult;
79461 }
79462
79463
79464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79465   unsigned int jresult ;
79466   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79467   float arg2 ;
79468   bool arg3 ;
79469   unsigned int result;
79470
79471   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79472   arg2 = (float)jarg2;
79473   arg3 = jarg3 ? true : false;
79474   {
79475     try {
79476       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79477     } catch (std::out_of_range& e) {
79478       {
79479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79480       };
79481     } catch (std::exception& e) {
79482       {
79483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79484       };
79485     } catch (Dali::DaliException e) {
79486       {
79487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79488       };
79489     } catch (...) {
79490       {
79491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79492       };
79493     }
79494   }
79495
79496   jresult = result;
79497   return jresult;
79498 }
79499
79500
79501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79502   unsigned int jresult ;
79503   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79504   unsigned int result;
79505
79506   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79507   {
79508     try {
79509       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79510     } catch (std::out_of_range& e) {
79511       {
79512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79513       };
79514     } catch (std::exception& e) {
79515       {
79516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79517       };
79518     } catch (Dali::DaliException e) {
79519       {
79520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79521       };
79522     } catch (...) {
79523       {
79524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79525       };
79526     }
79527   }
79528
79529   jresult = result;
79530   return jresult;
79531 }
79532
79533
79534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79535   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79536
79537   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79538   {
79539     try {
79540       delete arg1;
79541     } catch (std::out_of_range& e) {
79542       {
79543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79544       };
79545     } catch (std::exception& e) {
79546       {
79547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79548       };
79549     } catch (Dali::DaliException e) {
79550       {
79551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79552       };
79553     } catch (...) {
79554       {
79555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79556       };
79557     }
79558   }
79559
79560 }
79561
79562
79563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79564   void * jresult ;
79565   float arg1 ;
79566   Dali::Toolkit::FixedRuler *result = 0 ;
79567
79568   arg1 = (float)jarg1;
79569   {
79570     try {
79571       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79572     } catch (std::out_of_range& e) {
79573       {
79574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79575       };
79576     } catch (std::exception& e) {
79577       {
79578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79579       };
79580     } catch (Dali::DaliException e) {
79581       {
79582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79583       };
79584     } catch (...) {
79585       {
79586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79587       };
79588     }
79589   }
79590
79591   jresult = (void *)result;
79592   return jresult;
79593 }
79594
79595
79596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79597   void * jresult ;
79598   Dali::Toolkit::FixedRuler *result = 0 ;
79599
79600   {
79601     try {
79602       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79603     } catch (std::out_of_range& e) {
79604       {
79605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79606       };
79607     } catch (std::exception& e) {
79608       {
79609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79610       };
79611     } catch (Dali::DaliException e) {
79612       {
79613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79614       };
79615     } catch (...) {
79616       {
79617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79618       };
79619     }
79620   }
79621
79622   jresult = (void *)result;
79623   return jresult;
79624 }
79625
79626
79627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79628   float jresult ;
79629   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79630   float arg2 ;
79631   float arg3 ;
79632   float result;
79633
79634   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79635   arg2 = (float)jarg2;
79636   arg3 = (float)jarg3;
79637   {
79638     try {
79639       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79640     } catch (std::out_of_range& e) {
79641       {
79642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79643       };
79644     } catch (std::exception& e) {
79645       {
79646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79647       };
79648     } catch (Dali::DaliException e) {
79649       {
79650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79651       };
79652     } catch (...) {
79653       {
79654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79655       };
79656     }
79657   }
79658
79659   jresult = result;
79660   return jresult;
79661 }
79662
79663
79664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79665   float jresult ;
79666   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79667   unsigned int arg2 ;
79668   unsigned int *arg3 = 0 ;
79669   bool arg4 ;
79670   float result;
79671
79672   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79673   arg2 = (unsigned int)jarg2;
79674   arg3 = (unsigned int *)jarg3;
79675   arg4 = jarg4 ? true : false;
79676   {
79677     try {
79678       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79679     } catch (std::out_of_range& e) {
79680       {
79681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79682       };
79683     } catch (std::exception& e) {
79684       {
79685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79686       };
79687     } catch (Dali::DaliException e) {
79688       {
79689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79690       };
79691     } catch (...) {
79692       {
79693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79694       };
79695     }
79696   }
79697
79698   jresult = result;
79699   return jresult;
79700 }
79701
79702
79703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79704   unsigned int jresult ;
79705   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79706   float arg2 ;
79707   bool arg3 ;
79708   unsigned int result;
79709
79710   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79711   arg2 = (float)jarg2;
79712   arg3 = jarg3 ? true : false;
79713   {
79714     try {
79715       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79716     } catch (std::out_of_range& e) {
79717       {
79718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79719       };
79720     } catch (std::exception& e) {
79721       {
79722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79723       };
79724     } catch (Dali::DaliException e) {
79725       {
79726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79727       };
79728     } catch (...) {
79729       {
79730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79731       };
79732     }
79733   }
79734
79735   jresult = result;
79736   return jresult;
79737 }
79738
79739
79740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79741   unsigned int jresult ;
79742   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79743   unsigned int result;
79744
79745   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79746   {
79747     try {
79748       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79749     } catch (std::out_of_range& e) {
79750       {
79751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79752       };
79753     } catch (std::exception& e) {
79754       {
79755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79756       };
79757     } catch (Dali::DaliException e) {
79758       {
79759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79760       };
79761     } catch (...) {
79762       {
79763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79764       };
79765     }
79766   }
79767
79768   jresult = result;
79769   return jresult;
79770 }
79771
79772
79773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79774   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79775
79776   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79777   {
79778     try {
79779       delete arg1;
79780     } catch (std::out_of_range& e) {
79781       {
79782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79783       };
79784     } catch (std::exception& e) {
79785       {
79786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79787       };
79788     } catch (Dali::DaliException e) {
79789       {
79790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79791       };
79792     } catch (...) {
79793       {
79794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79795       };
79796     }
79797   }
79798
79799 }
79800
79801
79802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79803   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79804   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79805
79806   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79807   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79808   if (arg1) (arg1)->scale = *arg2;
79809 }
79810
79811
79812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79813   void * jresult ;
79814   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79815   Dali::Toolkit::ClampState2D *result = 0 ;
79816
79817   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79818   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79819   jresult = (void *)result;
79820   return jresult;
79821 }
79822
79823
79824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79825   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79826   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79827
79828   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79829   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79830   if (arg1) (arg1)->position = *arg2;
79831 }
79832
79833
79834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79835   void * jresult ;
79836   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79837   Dali::Toolkit::ClampState2D *result = 0 ;
79838
79839   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79840   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79841   jresult = (void *)result;
79842   return jresult;
79843 }
79844
79845
79846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79847   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79848   Dali::Toolkit::ClampState arg2 ;
79849
79850   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79851   arg2 = (Dali::Toolkit::ClampState)jarg2;
79852   if (arg1) (arg1)->rotation = arg2;
79853 }
79854
79855
79856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79857   int jresult ;
79858   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79859   Dali::Toolkit::ClampState result;
79860
79861   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79862   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79863   jresult = (int)result;
79864   return jresult;
79865 }
79866
79867
79868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79869   void * jresult ;
79870   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79871
79872   {
79873     try {
79874       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79875     } catch (std::out_of_range& e) {
79876       {
79877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79878       };
79879     } catch (std::exception& e) {
79880       {
79881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79882       };
79883     } catch (Dali::DaliException e) {
79884       {
79885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79886       };
79887     } catch (...) {
79888       {
79889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79890       };
79891     }
79892   }
79893
79894   jresult = (void *)result;
79895   return jresult;
79896 }
79897
79898
79899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79900   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79901
79902   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79903   {
79904     try {
79905       delete arg1;
79906     } catch (std::out_of_range& e) {
79907       {
79908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79909       };
79910     } catch (std::exception& e) {
79911       {
79912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79913       };
79914     } catch (Dali::DaliException e) {
79915       {
79916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79917       };
79918     } catch (...) {
79919       {
79920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79921       };
79922     }
79923   }
79924
79925 }
79926
79927
79928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79929   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79930   Dali::Toolkit::SnapType arg2 ;
79931
79932   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79933   arg2 = (Dali::Toolkit::SnapType)jarg2;
79934   if (arg1) (arg1)->type = arg2;
79935 }
79936
79937
79938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79939   int jresult ;
79940   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79941   Dali::Toolkit::SnapType result;
79942
79943   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79944   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79945   jresult = (int)result;
79946   return jresult;
79947 }
79948
79949
79950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79951   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79952   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79953
79954   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79955   arg2 = (Dali::Vector2 *)jarg2;
79956   if (arg1) (arg1)->position = *arg2;
79957 }
79958
79959
79960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79961   void * jresult ;
79962   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79963   Dali::Vector2 *result = 0 ;
79964
79965   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79966   result = (Dali::Vector2 *)& ((arg1)->position);
79967   jresult = (void *)result;
79968   return jresult;
79969 }
79970
79971
79972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79973   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79974   float arg2 ;
79975
79976   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79977   arg2 = (float)jarg2;
79978   if (arg1) (arg1)->duration = arg2;
79979 }
79980
79981
79982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79983   float jresult ;
79984   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79985   float result;
79986
79987   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79988   result = (float) ((arg1)->duration);
79989   jresult = result;
79990   return jresult;
79991 }
79992
79993
79994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79995   void * jresult ;
79996   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79997
79998   {
79999     try {
80000       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
80001     } catch (std::out_of_range& e) {
80002       {
80003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80004       };
80005     } catch (std::exception& e) {
80006       {
80007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80008       };
80009     } catch (Dali::DaliException e) {
80010       {
80011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80012       };
80013     } catch (...) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80016       };
80017     }
80018   }
80019
80020   jresult = (void *)result;
80021   return jresult;
80022 }
80023
80024
80025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
80026   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80027
80028   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80029   {
80030     try {
80031       delete arg1;
80032     } catch (std::out_of_range& e) {
80033       {
80034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80035       };
80036     } catch (std::exception& e) {
80037       {
80038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80039       };
80040     } catch (Dali::DaliException e) {
80041       {
80042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80043       };
80044     } catch (...) {
80045       {
80046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80047       };
80048     }
80049   }
80050
80051 }
80052
80053
80054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
80055   int jresult ;
80056   int result;
80057
80058   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
80059   jresult = (int)result;
80060   return jresult;
80061 }
80062
80063
80064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
80065   int jresult ;
80066   int result;
80067
80068   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80069   jresult = (int)result;
80070   return jresult;
80071 }
80072
80073
80074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80075   int jresult ;
80076   int result;
80077
80078   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80079   jresult = (int)result;
80080   return jresult;
80081 }
80082
80083
80084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80085   int jresult ;
80086   int result;
80087
80088   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80089   jresult = (int)result;
80090   return jresult;
80091 }
80092
80093
80094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80095   int jresult ;
80096   int result;
80097
80098   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80099   jresult = (int)result;
80100   return jresult;
80101 }
80102
80103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80104   int jresult ;
80105   int result;
80106
80107   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80108   jresult = (int)result;
80109   return jresult;
80110 }
80111
80112
80113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80114   int jresult ;
80115   int result;
80116
80117   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80118   jresult = (int)result;
80119   return jresult;
80120 }
80121
80122
80123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80124   int jresult ;
80125   int result;
80126
80127   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80128   jresult = (int)result;
80129   return jresult;
80130 }
80131
80132
80133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80134   int jresult ;
80135   int result;
80136
80137   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80138   jresult = (int)result;
80139   return jresult;
80140 }
80141
80142
80143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80144   int jresult ;
80145   int result;
80146
80147   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80148   jresult = (int)result;
80149   return jresult;
80150 }
80151
80152
80153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80154   int jresult ;
80155   int result;
80156
80157   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80158   jresult = (int)result;
80159   return jresult;
80160 }
80161
80162
80163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80164   int jresult ;
80165   int result;
80166
80167   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80168   jresult = (int)result;
80169   return jresult;
80170 }
80171
80172
80173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80174   int jresult ;
80175   int result;
80176
80177   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80178   jresult = (int)result;
80179   return jresult;
80180 }
80181
80182
80183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80184   int jresult ;
80185   int result;
80186
80187   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80188   jresult = (int)result;
80189   return jresult;
80190 }
80191
80192
80193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80194   int jresult ;
80195   int result;
80196
80197   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80198   jresult = (int)result;
80199   return jresult;
80200 }
80201
80202
80203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80204   int jresult ;
80205   int result;
80206
80207   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80208   jresult = (int)result;
80209   return jresult;
80210 }
80211
80212
80213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80214   int jresult ;
80215   int result;
80216
80217   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80218   jresult = (int)result;
80219   return jresult;
80220 }
80221
80222
80223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80224   int jresult ;
80225   int result;
80226
80227   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80228   jresult = (int)result;
80229   return jresult;
80230 }
80231
80232
80233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80234   int jresult ;
80235   int result;
80236
80237   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80238   jresult = (int)result;
80239   return jresult;
80240 }
80241
80242
80243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80244   int jresult ;
80245   int result;
80246
80247   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80248   jresult = (int)result;
80249   return jresult;
80250 }
80251
80252
80253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80254   int jresult ;
80255   int result;
80256
80257   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80258   jresult = (int)result;
80259   return jresult;
80260 }
80261
80262
80263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80264   int jresult ;
80265   int result;
80266
80267   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80268   jresult = (int)result;
80269   return jresult;
80270 }
80271
80272
80273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80274   int jresult ;
80275   int result;
80276
80277   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80278   jresult = (int)result;
80279   return jresult;
80280 }
80281
80282
80283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80284   int jresult ;
80285   int result;
80286
80287   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80288   jresult = (int)result;
80289   return jresult;
80290 }
80291
80292
80293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80294   int jresult ;
80295   int result;
80296
80297   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80298   jresult = (int)result;
80299   return jresult;
80300 }
80301
80302
80303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80304   int jresult ;
80305   int result;
80306
80307   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80308   jresult = (int)result;
80309   return jresult;
80310 }
80311
80312
80313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80314   void * jresult ;
80315   Dali::Toolkit::ScrollView::Property *result = 0 ;
80316
80317   {
80318     try {
80319       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80320     } catch (std::out_of_range& e) {
80321       {
80322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80323       };
80324     } catch (std::exception& e) {
80325       {
80326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80327       };
80328     } catch (Dali::DaliException e) {
80329       {
80330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80331       };
80332     } catch (...) {
80333       {
80334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80335       };
80336     }
80337   }
80338
80339   jresult = (void *)result;
80340   return jresult;
80341 }
80342
80343
80344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80345   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80346
80347   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80348   {
80349     try {
80350       delete arg1;
80351     } catch (std::out_of_range& e) {
80352       {
80353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80354       };
80355     } catch (std::exception& e) {
80356       {
80357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80358       };
80359     } catch (Dali::DaliException e) {
80360       {
80361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80362       };
80363     } catch (...) {
80364       {
80365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80366       };
80367     }
80368   }
80369
80370 }
80371
80372
80373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80374   void * jresult ;
80375   Dali::Toolkit::ScrollView *result = 0 ;
80376
80377   {
80378     try {
80379       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80380     } catch (std::out_of_range& e) {
80381       {
80382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80383       };
80384     } catch (std::exception& e) {
80385       {
80386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80387       };
80388     } catch (Dali::DaliException e) {
80389       {
80390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80391       };
80392     } catch (...) {
80393       {
80394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80395       };
80396     }
80397   }
80398
80399   jresult = (void *)result;
80400   return jresult;
80401 }
80402
80403
80404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80405   void * jresult ;
80406   Dali::Toolkit::ScrollView *arg1 = 0 ;
80407   Dali::Toolkit::ScrollView *result = 0 ;
80408
80409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80410   if (!arg1) {
80411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80412     return 0;
80413   }
80414   {
80415     try {
80416       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80417     } catch (std::out_of_range& e) {
80418       {
80419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80420       };
80421     } catch (std::exception& e) {
80422       {
80423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80424       };
80425     } catch (Dali::DaliException e) {
80426       {
80427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80428       };
80429     } catch (...) {
80430       {
80431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80432       };
80433     }
80434   }
80435
80436   jresult = (void *)result;
80437   return jresult;
80438 }
80439
80440
80441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80442   void * jresult ;
80443   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80444   Dali::Toolkit::ScrollView *arg2 = 0 ;
80445   Dali::Toolkit::ScrollView *result = 0 ;
80446
80447   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80448   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80449   if (!arg2) {
80450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80451     return 0;
80452   }
80453   {
80454     try {
80455       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80456     } catch (std::out_of_range& e) {
80457       {
80458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80459       };
80460     } catch (std::exception& e) {
80461       {
80462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80463       };
80464     } catch (Dali::DaliException e) {
80465       {
80466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80467       };
80468     } catch (...) {
80469       {
80470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80471       };
80472     }
80473   }
80474
80475   jresult = (void *)result;
80476   return jresult;
80477 }
80478
80479
80480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80481   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80482
80483   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80484   {
80485     try {
80486       delete arg1;
80487     } catch (std::out_of_range& e) {
80488       {
80489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80490       };
80491     } catch (std::exception& e) {
80492       {
80493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80494       };
80495     } catch (Dali::DaliException e) {
80496       {
80497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80498       };
80499     } catch (...) {
80500       {
80501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80502       };
80503     }
80504   }
80505
80506 }
80507
80508
80509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80510   void * jresult ;
80511   Dali::Toolkit::ScrollView result;
80512
80513   {
80514     try {
80515       result = Dali::Toolkit::ScrollView::New();
80516     } catch (std::out_of_range& e) {
80517       {
80518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80519       };
80520     } catch (std::exception& e) {
80521       {
80522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80523       };
80524     } catch (Dali::DaliException e) {
80525       {
80526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80527       };
80528     } catch (...) {
80529       {
80530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80531       };
80532     }
80533   }
80534
80535   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80536   return jresult;
80537 }
80538
80539
80540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80541   void * jresult ;
80542   Dali::BaseHandle arg1 ;
80543   Dali::BaseHandle *argp1 ;
80544   Dali::Toolkit::ScrollView result;
80545
80546   argp1 = (Dali::BaseHandle *)jarg1;
80547   if (!argp1) {
80548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80549     return 0;
80550   }
80551   arg1 = *argp1;
80552   {
80553     try {
80554       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80555     } catch (std::out_of_range& e) {
80556       {
80557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80558       };
80559     } catch (std::exception& e) {
80560       {
80561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80562       };
80563     } catch (Dali::DaliException e) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80566       };
80567     } catch (...) {
80568       {
80569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80570       };
80571     }
80572   }
80573
80574   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80575   return jresult;
80576 }
80577
80578
80579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80580   void * jresult ;
80581   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80582   Dali::AlphaFunction result;
80583
80584   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80585   {
80586     try {
80587       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80588     } catch (std::out_of_range& e) {
80589       {
80590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80591       };
80592     } catch (std::exception& e) {
80593       {
80594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80595       };
80596     } catch (Dali::DaliException e) {
80597       {
80598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80599       };
80600     } catch (...) {
80601       {
80602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80603       };
80604     }
80605   }
80606
80607   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80608   return jresult;
80609 }
80610
80611
80612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80613   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80614   Dali::AlphaFunction arg2 ;
80615   Dali::AlphaFunction *argp2 ;
80616
80617   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80618   argp2 = (Dali::AlphaFunction *)jarg2;
80619   if (!argp2) {
80620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80621     return ;
80622   }
80623   arg2 = *argp2;
80624   {
80625     try {
80626       (arg1)->SetScrollSnapAlphaFunction(arg2);
80627     } catch (std::out_of_range& e) {
80628       {
80629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80630       };
80631     } catch (std::exception& e) {
80632       {
80633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80634       };
80635     } catch (Dali::DaliException e) {
80636       {
80637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80638       };
80639     } catch (...) {
80640       {
80641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80642       };
80643     }
80644   }
80645
80646 }
80647
80648
80649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80650   void * jresult ;
80651   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80652   Dali::AlphaFunction result;
80653
80654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80655   {
80656     try {
80657       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80658     } catch (std::out_of_range& e) {
80659       {
80660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80661       };
80662     } catch (std::exception& e) {
80663       {
80664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80665       };
80666     } catch (Dali::DaliException e) {
80667       {
80668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80669       };
80670     } catch (...) {
80671       {
80672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80673       };
80674     }
80675   }
80676
80677   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80678   return jresult;
80679 }
80680
80681
80682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80683   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80684   Dali::AlphaFunction arg2 ;
80685   Dali::AlphaFunction *argp2 ;
80686
80687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80688   argp2 = (Dali::AlphaFunction *)jarg2;
80689   if (!argp2) {
80690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80691     return ;
80692   }
80693   arg2 = *argp2;
80694   {
80695     try {
80696       (arg1)->SetScrollFlickAlphaFunction(arg2);
80697     } catch (std::out_of_range& e) {
80698       {
80699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80700       };
80701     } catch (std::exception& e) {
80702       {
80703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80704       };
80705     } catch (Dali::DaliException e) {
80706       {
80707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80708       };
80709     } catch (...) {
80710       {
80711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80712       };
80713     }
80714   }
80715
80716 }
80717
80718
80719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80720   float jresult ;
80721   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80722   float result;
80723
80724   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80725   {
80726     try {
80727       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80728     } catch (std::out_of_range& e) {
80729       {
80730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80731       };
80732     } catch (std::exception& e) {
80733       {
80734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80735       };
80736     } catch (Dali::DaliException e) {
80737       {
80738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80739       };
80740     } catch (...) {
80741       {
80742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80743       };
80744     }
80745   }
80746
80747   jresult = result;
80748   return jresult;
80749 }
80750
80751
80752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80754   float arg2 ;
80755
80756   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80757   arg2 = (float)jarg2;
80758   {
80759     try {
80760       (arg1)->SetScrollSnapDuration(arg2);
80761     } catch (std::out_of_range& e) {
80762       {
80763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80764       };
80765     } catch (std::exception& e) {
80766       {
80767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80768       };
80769     } catch (Dali::DaliException e) {
80770       {
80771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80772       };
80773     } catch (...) {
80774       {
80775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80776       };
80777     }
80778   }
80779
80780 }
80781
80782
80783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80784   float jresult ;
80785   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80786   float result;
80787
80788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80789   {
80790     try {
80791       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80792     } catch (std::out_of_range& e) {
80793       {
80794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80795       };
80796     } catch (std::exception& e) {
80797       {
80798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80799       };
80800     } catch (Dali::DaliException e) {
80801       {
80802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80803       };
80804     } catch (...) {
80805       {
80806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80807       };
80808     }
80809   }
80810
80811   jresult = result;
80812   return jresult;
80813 }
80814
80815
80816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80818   float arg2 ;
80819
80820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80821   arg2 = (float)jarg2;
80822   {
80823     try {
80824       (arg1)->SetScrollFlickDuration(arg2);
80825     } catch (std::out_of_range& e) {
80826       {
80827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80828       };
80829     } catch (std::exception& e) {
80830       {
80831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80832       };
80833     } catch (Dali::DaliException e) {
80834       {
80835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80836       };
80837     } catch (...) {
80838       {
80839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80840       };
80841     }
80842   }
80843
80844 }
80845
80846
80847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80848   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80849   Dali::Toolkit::RulerPtr arg2 ;
80850   Dali::Toolkit::RulerPtr *argp2 ;
80851
80852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80853   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80854   if (!argp2) {
80855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80856     return ;
80857   }
80858   arg2 = *argp2;
80859   {
80860     try {
80861       (arg1)->SetRulerX(arg2);
80862     } catch (std::out_of_range& e) {
80863       {
80864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80865       };
80866     } catch (std::exception& e) {
80867       {
80868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80869       };
80870     } catch (Dali::DaliException e) {
80871       {
80872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80873       };
80874     } catch (...) {
80875       {
80876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80877       };
80878     }
80879   }
80880
80881 }
80882
80883
80884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80886   Dali::Toolkit::RulerPtr arg2 ;
80887   Dali::Toolkit::RulerPtr *argp2 ;
80888
80889   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80890   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80891   if (!argp2) {
80892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80893     return ;
80894   }
80895   arg2 = *argp2;
80896   {
80897     try {
80898       (arg1)->SetRulerY(arg2);
80899     } catch (std::out_of_range& e) {
80900       {
80901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80902       };
80903     } catch (std::exception& e) {
80904       {
80905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80906       };
80907     } catch (Dali::DaliException e) {
80908       {
80909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80910       };
80911     } catch (...) {
80912       {
80913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80914       };
80915     }
80916   }
80917
80918 }
80919
80920
80921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80922   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80923   bool arg2 ;
80924
80925   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80926   arg2 = jarg2 ? true : false;
80927   {
80928     try {
80929       (arg1)->SetScrollSensitive(arg2);
80930     } catch (std::out_of_range& e) {
80931       {
80932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80933       };
80934     } catch (std::exception& e) {
80935       {
80936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80937       };
80938     } catch (Dali::DaliException e) {
80939       {
80940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80941       };
80942     } catch (...) {
80943       {
80944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80945       };
80946     }
80947   }
80948
80949 }
80950
80951
80952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80954   float arg2 ;
80955   float arg3 ;
80956
80957   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80958   arg2 = (float)jarg2;
80959   arg3 = (float)jarg3;
80960   {
80961     try {
80962       (arg1)->SetMaxOvershoot(arg2,arg3);
80963     } catch (std::out_of_range& e) {
80964       {
80965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80966       };
80967     } catch (std::exception& e) {
80968       {
80969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80970       };
80971     } catch (Dali::DaliException e) {
80972       {
80973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80974       };
80975     } catch (...) {
80976       {
80977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80978       };
80979     }
80980   }
80981
80982 }
80983
80984
80985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80987   Dali::AlphaFunction arg2 ;
80988   Dali::AlphaFunction *argp2 ;
80989
80990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80991   argp2 = (Dali::AlphaFunction *)jarg2;
80992   if (!argp2) {
80993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80994     return ;
80995   }
80996   arg2 = *argp2;
80997   {
80998     try {
80999       (arg1)->SetSnapOvershootAlphaFunction(arg2);
81000     } catch (std::out_of_range& e) {
81001       {
81002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81003       };
81004     } catch (std::exception& e) {
81005       {
81006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81007       };
81008     } catch (Dali::DaliException e) {
81009       {
81010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81011       };
81012     } catch (...) {
81013       {
81014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81015       };
81016     }
81017   }
81018
81019 }
81020
81021
81022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
81023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81024   float arg2 ;
81025
81026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81027   arg2 = (float)jarg2;
81028   {
81029     try {
81030       (arg1)->SetSnapOvershootDuration(arg2);
81031     } catch (std::out_of_range& e) {
81032       {
81033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81034       };
81035     } catch (std::exception& e) {
81036       {
81037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81038       };
81039     } catch (Dali::DaliException e) {
81040       {
81041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81042       };
81043     } catch (...) {
81044       {
81045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81046       };
81047     }
81048   }
81049
81050 }
81051
81052
81053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
81054   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81055   bool arg2 ;
81056
81057   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81058   arg2 = jarg2 ? true : false;
81059   {
81060     try {
81061       (arg1)->SetActorAutoSnap(arg2);
81062     } catch (std::out_of_range& e) {
81063       {
81064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81065       };
81066     } catch (std::exception& e) {
81067       {
81068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81069       };
81070     } catch (Dali::DaliException e) {
81071       {
81072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81073       };
81074     } catch (...) {
81075       {
81076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81077       };
81078     }
81079   }
81080
81081 }
81082
81083
81084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81085   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81086   bool arg2 ;
81087
81088   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81089   arg2 = jarg2 ? true : false;
81090   {
81091     try {
81092       (arg1)->SetWrapMode(arg2);
81093     } catch (std::out_of_range& e) {
81094       {
81095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81096       };
81097     } catch (std::exception& e) {
81098       {
81099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81100       };
81101     } catch (Dali::DaliException e) {
81102       {
81103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81104       };
81105     } catch (...) {
81106       {
81107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81108       };
81109     }
81110   }
81111
81112 }
81113
81114
81115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81116   int jresult ;
81117   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81118   int result;
81119
81120   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81121   {
81122     try {
81123       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81124     } catch (std::out_of_range& e) {
81125       {
81126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81127       };
81128     } catch (std::exception& e) {
81129       {
81130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81131       };
81132     } catch (Dali::DaliException e) {
81133       {
81134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81135       };
81136     } catch (...) {
81137       {
81138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81139       };
81140     }
81141   }
81142
81143   jresult = result;
81144   return jresult;
81145 }
81146
81147
81148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81149   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81150   int arg2 ;
81151
81152   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81153   arg2 = (int)jarg2;
81154   {
81155     try {
81156       (arg1)->SetScrollUpdateDistance(arg2);
81157     } catch (std::out_of_range& e) {
81158       {
81159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81160       };
81161     } catch (std::exception& e) {
81162       {
81163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81164       };
81165     } catch (Dali::DaliException e) {
81166       {
81167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81168       };
81169     } catch (...) {
81170       {
81171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81172       };
81173     }
81174   }
81175
81176 }
81177
81178
81179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81180   unsigned int jresult ;
81181   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81182   bool result;
81183
81184   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81185   {
81186     try {
81187       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81188     } catch (std::out_of_range& e) {
81189       {
81190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81191       };
81192     } catch (std::exception& e) {
81193       {
81194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81195       };
81196     } catch (Dali::DaliException e) {
81197       {
81198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81199       };
81200     } catch (...) {
81201       {
81202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81203       };
81204     }
81205   }
81206
81207   jresult = result;
81208   return jresult;
81209 }
81210
81211
81212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81213   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81214   bool arg2 ;
81215
81216   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81217   arg2 = jarg2 ? true : false;
81218   {
81219     try {
81220       (arg1)->SetAxisAutoLock(arg2);
81221     } catch (std::out_of_range& e) {
81222       {
81223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81224       };
81225     } catch (std::exception& e) {
81226       {
81227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81228       };
81229     } catch (Dali::DaliException e) {
81230       {
81231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81232       };
81233     } catch (...) {
81234       {
81235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81236       };
81237     }
81238   }
81239
81240 }
81241
81242
81243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81244   float jresult ;
81245   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81246   float result;
81247
81248   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81249   {
81250     try {
81251       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81252     } catch (std::out_of_range& e) {
81253       {
81254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81255       };
81256     } catch (std::exception& e) {
81257       {
81258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81259       };
81260     } catch (Dali::DaliException e) {
81261       {
81262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81263       };
81264     } catch (...) {
81265       {
81266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81267       };
81268     }
81269   }
81270
81271   jresult = result;
81272   return jresult;
81273 }
81274
81275
81276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81277   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81278   float arg2 ;
81279
81280   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81281   arg2 = (float)jarg2;
81282   {
81283     try {
81284       (arg1)->SetAxisAutoLockGradient(arg2);
81285     } catch (std::out_of_range& e) {
81286       {
81287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81288       };
81289     } catch (std::exception& e) {
81290       {
81291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81292       };
81293     } catch (Dali::DaliException e) {
81294       {
81295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81296       };
81297     } catch (...) {
81298       {
81299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81300       };
81301     }
81302   }
81303
81304 }
81305
81306
81307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81308   float jresult ;
81309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81310   float result;
81311
81312   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81313   {
81314     try {
81315       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81316     } catch (std::out_of_range& e) {
81317       {
81318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81319       };
81320     } catch (std::exception& e) {
81321       {
81322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81323       };
81324     } catch (Dali::DaliException e) {
81325       {
81326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81327       };
81328     } catch (...) {
81329       {
81330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81331       };
81332     }
81333   }
81334
81335   jresult = result;
81336   return jresult;
81337 }
81338
81339
81340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81342   float arg2 ;
81343
81344   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81345   arg2 = (float)jarg2;
81346   {
81347     try {
81348       (arg1)->SetFrictionCoefficient(arg2);
81349     } catch (std::out_of_range& e) {
81350       {
81351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81352       };
81353     } catch (std::exception& e) {
81354       {
81355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81356       };
81357     } catch (Dali::DaliException e) {
81358       {
81359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81360       };
81361     } catch (...) {
81362       {
81363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81364       };
81365     }
81366   }
81367
81368 }
81369
81370
81371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81372   float jresult ;
81373   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81374   float result;
81375
81376   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81377   {
81378     try {
81379       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81380     } catch (std::out_of_range& e) {
81381       {
81382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81383       };
81384     } catch (std::exception& e) {
81385       {
81386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81387       };
81388     } catch (Dali::DaliException e) {
81389       {
81390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81391       };
81392     } catch (...) {
81393       {
81394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81395       };
81396     }
81397   }
81398
81399   jresult = result;
81400   return jresult;
81401 }
81402
81403
81404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81406   float arg2 ;
81407
81408   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81409   arg2 = (float)jarg2;
81410   {
81411     try {
81412       (arg1)->SetFlickSpeedCoefficient(arg2);
81413     } catch (std::out_of_range& e) {
81414       {
81415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81416       };
81417     } catch (std::exception& e) {
81418       {
81419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81420       };
81421     } catch (Dali::DaliException e) {
81422       {
81423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81424       };
81425     } catch (...) {
81426       {
81427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81428       };
81429     }
81430   }
81431
81432 }
81433
81434
81435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81436   void * jresult ;
81437   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81438   Dali::Vector2 result;
81439
81440   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81441   {
81442     try {
81443       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81444     } catch (std::out_of_range& e) {
81445       {
81446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81447       };
81448     } catch (std::exception& e) {
81449       {
81450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81451       };
81452     } catch (Dali::DaliException e) {
81453       {
81454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81455       };
81456     } catch (...) {
81457       {
81458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81459       };
81460     }
81461   }
81462
81463   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81464   return jresult;
81465 }
81466
81467
81468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81469   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81470   Dali::Vector2 *arg2 = 0 ;
81471
81472   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81473   arg2 = (Dali::Vector2 *)jarg2;
81474   if (!arg2) {
81475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81476     return ;
81477   }
81478   {
81479     try {
81480       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81481     } catch (std::out_of_range& e) {
81482       {
81483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81484       };
81485     } catch (std::exception& e) {
81486       {
81487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81488       };
81489     } catch (Dali::DaliException e) {
81490       {
81491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81492       };
81493     } catch (...) {
81494       {
81495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81496       };
81497     }
81498   }
81499
81500 }
81501
81502
81503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81504   float jresult ;
81505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81506   float result;
81507
81508   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81509   {
81510     try {
81511       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81512     } catch (std::out_of_range& e) {
81513       {
81514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81515       };
81516     } catch (std::exception& e) {
81517       {
81518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81519       };
81520     } catch (Dali::DaliException e) {
81521       {
81522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81523       };
81524     } catch (...) {
81525       {
81526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81527       };
81528     }
81529   }
81530
81531   jresult = result;
81532   return jresult;
81533 }
81534
81535
81536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81538   float arg2 ;
81539
81540   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81541   arg2 = (float)jarg2;
81542   {
81543     try {
81544       (arg1)->SetMinimumSpeedForFlick(arg2);
81545     } catch (std::out_of_range& e) {
81546       {
81547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81548       };
81549     } catch (std::exception& e) {
81550       {
81551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81552       };
81553     } catch (Dali::DaliException e) {
81554       {
81555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81556       };
81557     } catch (...) {
81558       {
81559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81560       };
81561     }
81562   }
81563
81564 }
81565
81566
81567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81568   float jresult ;
81569   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81570   float result;
81571
81572   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81573   {
81574     try {
81575       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81576     } catch (std::out_of_range& e) {
81577       {
81578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81579       };
81580     } catch (std::exception& e) {
81581       {
81582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81583       };
81584     } catch (Dali::DaliException e) {
81585       {
81586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81587       };
81588     } catch (...) {
81589       {
81590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81591       };
81592     }
81593   }
81594
81595   jresult = result;
81596   return jresult;
81597 }
81598
81599
81600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81601   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81602   float arg2 ;
81603
81604   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81605   arg2 = (float)jarg2;
81606   {
81607     try {
81608       (arg1)->SetMaxFlickSpeed(arg2);
81609     } catch (std::out_of_range& e) {
81610       {
81611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81612       };
81613     } catch (std::exception& e) {
81614       {
81615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81616       };
81617     } catch (Dali::DaliException e) {
81618       {
81619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81620       };
81621     } catch (...) {
81622       {
81623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81624       };
81625     }
81626   }
81627
81628 }
81629
81630
81631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81632   void * jresult ;
81633   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81634   Dali::Vector2 result;
81635
81636   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81637   {
81638     try {
81639       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81640     } catch (std::out_of_range& e) {
81641       {
81642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81643       };
81644     } catch (std::exception& e) {
81645       {
81646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81647       };
81648     } catch (Dali::DaliException e) {
81649       {
81650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81651       };
81652     } catch (...) {
81653       {
81654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81655       };
81656     }
81657   }
81658
81659   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81660   return jresult;
81661 }
81662
81663
81664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81665   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81666   Dali::Vector2 arg2 ;
81667   Dali::Vector2 *argp2 ;
81668
81669   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81670   argp2 = (Dali::Vector2 *)jarg2;
81671   if (!argp2) {
81672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81673     return ;
81674   }
81675   arg2 = *argp2;
81676   {
81677     try {
81678       (arg1)->SetWheelScrollDistanceStep(arg2);
81679     } catch (std::out_of_range& e) {
81680       {
81681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81682       };
81683     } catch (std::exception& e) {
81684       {
81685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81686       };
81687     } catch (Dali::DaliException e) {
81688       {
81689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81690       };
81691     } catch (...) {
81692       {
81693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81694       };
81695     }
81696   }
81697
81698 }
81699
81700
81701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81702   void * jresult ;
81703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81704   Dali::Vector2 result;
81705
81706   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81707   {
81708     try {
81709       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81710     } catch (std::out_of_range& e) {
81711       {
81712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81713       };
81714     } catch (std::exception& e) {
81715       {
81716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81717       };
81718     } catch (Dali::DaliException e) {
81719       {
81720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81721       };
81722     } catch (...) {
81723       {
81724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81725       };
81726     }
81727   }
81728
81729   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81730   return jresult;
81731 }
81732
81733
81734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81735   unsigned int jresult ;
81736   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81737   unsigned int result;
81738
81739   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81740   {
81741     try {
81742       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81743     } catch (std::out_of_range& e) {
81744       {
81745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81746       };
81747     } catch (std::exception& e) {
81748       {
81749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81750       };
81751     } catch (Dali::DaliException e) {
81752       {
81753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81754       };
81755     } catch (...) {
81756       {
81757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81758       };
81759     }
81760   }
81761
81762   jresult = result;
81763   return jresult;
81764 }
81765
81766
81767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81768   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81769   Dali::Vector2 *arg2 = 0 ;
81770
81771   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81772   arg2 = (Dali::Vector2 *)jarg2;
81773   if (!arg2) {
81774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81775     return ;
81776   }
81777   {
81778     try {
81779       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81780     } catch (std::out_of_range& e) {
81781       {
81782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81783       };
81784     } catch (std::exception& e) {
81785       {
81786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81787       };
81788     } catch (Dali::DaliException e) {
81789       {
81790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81791       };
81792     } catch (...) {
81793       {
81794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81795       };
81796     }
81797   }
81798
81799 }
81800
81801
81802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81803   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81804   Dali::Vector2 *arg2 = 0 ;
81805   float arg3 ;
81806
81807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81808   arg2 = (Dali::Vector2 *)jarg2;
81809   if (!arg2) {
81810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81811     return ;
81812   }
81813   arg3 = (float)jarg3;
81814   {
81815     try {
81816       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81817     } catch (std::out_of_range& e) {
81818       {
81819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81820       };
81821     } catch (std::exception& e) {
81822       {
81823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81824       };
81825     } catch (Dali::DaliException e) {
81826       {
81827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81828       };
81829     } catch (...) {
81830       {
81831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81832       };
81833     }
81834   }
81835
81836 }
81837
81838
81839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81840   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81841   Dali::Vector2 *arg2 = 0 ;
81842   float arg3 ;
81843   Dali::AlphaFunction arg4 ;
81844   Dali::AlphaFunction *argp4 ;
81845
81846   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81847   arg2 = (Dali::Vector2 *)jarg2;
81848   if (!arg2) {
81849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81850     return ;
81851   }
81852   arg3 = (float)jarg3;
81853   argp4 = (Dali::AlphaFunction *)jarg4;
81854   if (!argp4) {
81855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81856     return ;
81857   }
81858   arg4 = *argp4;
81859   {
81860     try {
81861       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81862     } catch (std::out_of_range& e) {
81863       {
81864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81865       };
81866     } catch (std::exception& e) {
81867       {
81868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81869       };
81870     } catch (Dali::DaliException e) {
81871       {
81872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81873       };
81874     } catch (...) {
81875       {
81876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81877       };
81878     }
81879   }
81880
81881 }
81882
81883
81884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81886   Dali::Vector2 *arg2 = 0 ;
81887   float arg3 ;
81888   Dali::Toolkit::DirectionBias arg4 ;
81889   Dali::Toolkit::DirectionBias arg5 ;
81890
81891   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81892   arg2 = (Dali::Vector2 *)jarg2;
81893   if (!arg2) {
81894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81895     return ;
81896   }
81897   arg3 = (float)jarg3;
81898   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81899   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81900   {
81901     try {
81902       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81903     } catch (std::out_of_range& e) {
81904       {
81905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81906       };
81907     } catch (std::exception& e) {
81908       {
81909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81910       };
81911     } catch (Dali::DaliException e) {
81912       {
81913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81914       };
81915     } catch (...) {
81916       {
81917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81918       };
81919     }
81920   }
81921
81922 }
81923
81924
81925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81927   Dali::Vector2 *arg2 = 0 ;
81928   float arg3 ;
81929   Dali::AlphaFunction arg4 ;
81930   Dali::Toolkit::DirectionBias arg5 ;
81931   Dali::Toolkit::DirectionBias arg6 ;
81932   Dali::AlphaFunction *argp4 ;
81933
81934   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81935   arg2 = (Dali::Vector2 *)jarg2;
81936   if (!arg2) {
81937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81938     return ;
81939   }
81940   arg3 = (float)jarg3;
81941   argp4 = (Dali::AlphaFunction *)jarg4;
81942   if (!argp4) {
81943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81944     return ;
81945   }
81946   arg4 = *argp4;
81947   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81948   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81949   {
81950     try {
81951       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81952     } catch (std::out_of_range& e) {
81953       {
81954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81955       };
81956     } catch (std::exception& e) {
81957       {
81958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81959       };
81960     } catch (Dali::DaliException e) {
81961       {
81962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81963       };
81964     } catch (...) {
81965       {
81966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81967       };
81968     }
81969   }
81970
81971 }
81972
81973
81974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81975   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81976   unsigned int arg2 ;
81977
81978   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81979   arg2 = (unsigned int)jarg2;
81980   {
81981     try {
81982       (arg1)->ScrollTo(arg2);
81983     } catch (std::out_of_range& e) {
81984       {
81985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81986       };
81987     } catch (std::exception& e) {
81988       {
81989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81990       };
81991     } catch (Dali::DaliException e) {
81992       {
81993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81994       };
81995     } catch (...) {
81996       {
81997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81998       };
81999     }
82000   }
82001
82002 }
82003
82004
82005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
82006   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82007   unsigned int arg2 ;
82008   float arg3 ;
82009
82010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82011   arg2 = (unsigned int)jarg2;
82012   arg3 = (float)jarg3;
82013   {
82014     try {
82015       (arg1)->ScrollTo(arg2,arg3);
82016     } catch (std::out_of_range& e) {
82017       {
82018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82019       };
82020     } catch (std::exception& e) {
82021       {
82022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82023       };
82024     } catch (Dali::DaliException e) {
82025       {
82026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82027       };
82028     } catch (...) {
82029       {
82030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82031       };
82032     }
82033   }
82034
82035 }
82036
82037
82038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
82039   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82040   unsigned int arg2 ;
82041   float arg3 ;
82042   Dali::Toolkit::DirectionBias arg4 ;
82043
82044   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82045   arg2 = (unsigned int)jarg2;
82046   arg3 = (float)jarg3;
82047   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
82048   {
82049     try {
82050       (arg1)->ScrollTo(arg2,arg3,arg4);
82051     } catch (std::out_of_range& e) {
82052       {
82053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82054       };
82055     } catch (std::exception& e) {
82056       {
82057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82058       };
82059     } catch (Dali::DaliException e) {
82060       {
82061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82062       };
82063     } catch (...) {
82064       {
82065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82066       };
82067     }
82068   }
82069
82070 }
82071
82072
82073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82075   Dali::Actor *arg2 = 0 ;
82076
82077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82078   arg2 = (Dali::Actor *)jarg2;
82079   if (!arg2) {
82080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82081     return ;
82082   }
82083   {
82084     try {
82085       (arg1)->ScrollTo(*arg2);
82086     } catch (std::out_of_range& e) {
82087       {
82088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82089       };
82090     } catch (std::exception& e) {
82091       {
82092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82093       };
82094     } catch (Dali::DaliException e) {
82095       {
82096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82097       };
82098     } catch (...) {
82099       {
82100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82101       };
82102     }
82103   }
82104
82105 }
82106
82107
82108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82109   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82110   Dali::Actor *arg2 = 0 ;
82111   float arg3 ;
82112
82113   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82114   arg2 = (Dali::Actor *)jarg2;
82115   if (!arg2) {
82116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82117     return ;
82118   }
82119   arg3 = (float)jarg3;
82120   {
82121     try {
82122       (arg1)->ScrollTo(*arg2,arg3);
82123     } catch (std::out_of_range& e) {
82124       {
82125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82126       };
82127     } catch (std::exception& e) {
82128       {
82129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82130       };
82131     } catch (Dali::DaliException e) {
82132       {
82133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82134       };
82135     } catch (...) {
82136       {
82137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82138       };
82139     }
82140   }
82141
82142 }
82143
82144
82145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82146   unsigned int jresult ;
82147   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82148   bool result;
82149
82150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82151   {
82152     try {
82153       result = (bool)(arg1)->ScrollToSnapPoint();
82154     } catch (std::out_of_range& e) {
82155       {
82156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82157       };
82158     } catch (std::exception& e) {
82159       {
82160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82161       };
82162     } catch (Dali::DaliException e) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82165       };
82166     } catch (...) {
82167       {
82168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82169       };
82170     }
82171   }
82172
82173   jresult = result;
82174   return jresult;
82175 }
82176
82177
82178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82180   Dali::Constraint arg2 ;
82181   Dali::Constraint *argp2 ;
82182
82183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82184   argp2 = (Dali::Constraint *)jarg2;
82185   if (!argp2) {
82186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82187     return ;
82188   }
82189   arg2 = *argp2;
82190   {
82191     try {
82192       (arg1)->ApplyConstraintToChildren(arg2);
82193     } catch (std::out_of_range& e) {
82194       {
82195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82196       };
82197     } catch (std::exception& e) {
82198       {
82199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82200       };
82201     } catch (Dali::DaliException e) {
82202       {
82203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82204       };
82205     } catch (...) {
82206       {
82207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82208       };
82209     }
82210   }
82211
82212 }
82213
82214
82215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82216   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82217
82218   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82219   {
82220     try {
82221       (arg1)->RemoveConstraintsFromChildren();
82222     } catch (std::out_of_range& e) {
82223       {
82224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82225       };
82226     } catch (std::exception& e) {
82227       {
82228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82229       };
82230     } catch (Dali::DaliException e) {
82231       {
82232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82233       };
82234     } catch (...) {
82235       {
82236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82237       };
82238     }
82239   }
82240
82241 }
82242
82243
82244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82245   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82246   Dali::Toolkit::ScrollViewEffect arg2 ;
82247   Dali::Toolkit::ScrollViewEffect *argp2 ;
82248
82249   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82250   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82251   if (!argp2) {
82252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82253     return ;
82254   }
82255   arg2 = *argp2;
82256   {
82257     try {
82258       (arg1)->ApplyEffect(arg2);
82259     } catch (std::out_of_range& e) {
82260       {
82261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82262       };
82263     } catch (std::exception& e) {
82264       {
82265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82266       };
82267     } catch (Dali::DaliException e) {
82268       {
82269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82270       };
82271     } catch (...) {
82272       {
82273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82274       };
82275     }
82276   }
82277
82278 }
82279
82280
82281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82282   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82283   Dali::Toolkit::ScrollViewEffect arg2 ;
82284   Dali::Toolkit::ScrollViewEffect *argp2 ;
82285
82286   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82287   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82288   if (!argp2) {
82289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82290     return ;
82291   }
82292   arg2 = *argp2;
82293   {
82294     try {
82295       (arg1)->RemoveEffect(arg2);
82296     } catch (std::out_of_range& e) {
82297       {
82298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82299       };
82300     } catch (std::exception& e) {
82301       {
82302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82303       };
82304     } catch (Dali::DaliException e) {
82305       {
82306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82307       };
82308     } catch (...) {
82309       {
82310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82311       };
82312     }
82313   }
82314
82315 }
82316
82317
82318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82319   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82320
82321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82322   {
82323     try {
82324       (arg1)->RemoveAllEffects();
82325     } catch (std::out_of_range& e) {
82326       {
82327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82328       };
82329     } catch (std::exception& e) {
82330       {
82331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82332       };
82333     } catch (Dali::DaliException e) {
82334       {
82335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82336       };
82337     } catch (...) {
82338       {
82339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82340       };
82341     }
82342   }
82343
82344 }
82345
82346
82347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82348   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82349   Dali::Actor arg2 ;
82350   Dali::Actor *argp2 ;
82351
82352   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82353   argp2 = (Dali::Actor *)jarg2;
82354   if (!argp2) {
82355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82356     return ;
82357   }
82358   arg2 = *argp2;
82359   {
82360     try {
82361       (arg1)->BindActor(arg2);
82362     } catch (std::out_of_range& e) {
82363       {
82364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82365       };
82366     } catch (std::exception& e) {
82367       {
82368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82369       };
82370     } catch (Dali::DaliException e) {
82371       {
82372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82373       };
82374     } catch (...) {
82375       {
82376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82377       };
82378     }
82379   }
82380
82381 }
82382
82383
82384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82385   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82386   Dali::Actor arg2 ;
82387   Dali::Actor *argp2 ;
82388
82389   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82390   argp2 = (Dali::Actor *)jarg2;
82391   if (!argp2) {
82392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82393     return ;
82394   }
82395   arg2 = *argp2;
82396   {
82397     try {
82398       (arg1)->UnbindActor(arg2);
82399     } catch (std::out_of_range& e) {
82400       {
82401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82402       };
82403     } catch (std::exception& e) {
82404       {
82405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82406       };
82407     } catch (Dali::DaliException e) {
82408       {
82409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82410       };
82411     } catch (...) {
82412       {
82413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82414       };
82415     }
82416   }
82417
82418 }
82419
82420
82421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82423   Dali::Radian arg2 ;
82424   Dali::Radian arg3 ;
82425   Dali::Radian *argp2 ;
82426   Dali::Radian *argp3 ;
82427
82428   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82429   argp2 = (Dali::Radian *)jarg2;
82430   if (!argp2) {
82431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82432     return ;
82433   }
82434   arg2 = *argp2;
82435   argp3 = (Dali::Radian *)jarg3;
82436   if (!argp3) {
82437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82438     return ;
82439   }
82440   arg3 = *argp3;
82441   {
82442     try {
82443       (arg1)->SetScrollingDirection(arg2,arg3);
82444     } catch (std::out_of_range& e) {
82445       {
82446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82447       };
82448     } catch (std::exception& e) {
82449       {
82450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82451       };
82452     } catch (Dali::DaliException e) {
82453       {
82454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82455       };
82456     } catch (...) {
82457       {
82458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82459       };
82460     }
82461   }
82462
82463 }
82464
82465
82466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82467   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82468   Dali::Radian arg2 ;
82469   Dali::Radian *argp2 ;
82470
82471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82472   argp2 = (Dali::Radian *)jarg2;
82473   if (!argp2) {
82474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82475     return ;
82476   }
82477   arg2 = *argp2;
82478   {
82479     try {
82480       (arg1)->SetScrollingDirection(arg2);
82481     } catch (std::out_of_range& e) {
82482       {
82483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82484       };
82485     } catch (std::exception& e) {
82486       {
82487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82488       };
82489     } catch (Dali::DaliException e) {
82490       {
82491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82492       };
82493     } catch (...) {
82494       {
82495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82496       };
82497     }
82498   }
82499
82500 }
82501
82502
82503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82504   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82505   Dali::Radian arg2 ;
82506   Dali::Radian *argp2 ;
82507
82508   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82509   argp2 = (Dali::Radian *)jarg2;
82510   if (!argp2) {
82511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82512     return ;
82513   }
82514   arg2 = *argp2;
82515   {
82516     try {
82517       (arg1)->RemoveScrollingDirection(arg2);
82518     } catch (std::out_of_range& e) {
82519       {
82520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82521       };
82522     } catch (std::exception& e) {
82523       {
82524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82525       };
82526     } catch (Dali::DaliException e) {
82527       {
82528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82529       };
82530     } catch (...) {
82531       {
82532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82533       };
82534     }
82535   }
82536
82537 }
82538
82539
82540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82541   void * jresult ;
82542   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82543   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82544
82545   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82546   {
82547     try {
82548       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82549     } catch (std::out_of_range& e) {
82550       {
82551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82552       };
82553     } catch (std::exception& e) {
82554       {
82555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82556       };
82557     } catch (Dali::DaliException e) {
82558       {
82559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82560       };
82561     } catch (...) {
82562       {
82563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82564       };
82565     }
82566   }
82567
82568   jresult = (void *)result;
82569   return jresult;
82570 }
82571
82572
82573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82574   int jresult ;
82575   int result;
82576
82577   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82578   jresult = (int)result;
82579   return jresult;
82580 }
82581
82582
82583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82584   int jresult ;
82585   int result;
82586
82587   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82588   jresult = (int)result;
82589   return jresult;
82590 }
82591
82592
82593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82594   int jresult ;
82595   int result;
82596
82597   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82598   jresult = (int)result;
82599   return jresult;
82600 }
82601
82602
82603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82604   int jresult ;
82605   int result;
82606
82607   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82608   jresult = (int)result;
82609   return jresult;
82610 }
82611
82612
82613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82614   int jresult ;
82615   int result;
82616
82617   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82618   jresult = (int)result;
82619   return jresult;
82620 }
82621
82622
82623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82624   void * jresult ;
82625   Dali::Toolkit::TableView::Property *result = 0 ;
82626
82627   {
82628     try {
82629       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82630     } catch (std::out_of_range& e) {
82631       {
82632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82633       };
82634     } catch (std::exception& e) {
82635       {
82636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82637       };
82638     } catch (Dali::DaliException e) {
82639       {
82640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82641       };
82642     } catch (...) {
82643       {
82644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82645       };
82646     }
82647   }
82648
82649   jresult = (void *)result;
82650   return jresult;
82651 }
82652
82653
82654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82655   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82656
82657   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82658   {
82659     try {
82660       delete arg1;
82661     } catch (std::out_of_range& e) {
82662       {
82663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82664       };
82665     } catch (std::exception& e) {
82666       {
82667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82668       };
82669     } catch (Dali::DaliException e) {
82670       {
82671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82672       };
82673     } catch (...) {
82674       {
82675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82676       };
82677     }
82678   }
82679
82680 }
82681
82682
82683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82684   int jresult ;
82685   int result;
82686
82687   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82688   jresult = (int)result;
82689   return jresult;
82690 }
82691
82692
82693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82694   int jresult ;
82695   int result;
82696
82697   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82698   jresult = (int)result;
82699   return jresult;
82700 }
82701
82702
82703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82704   int jresult ;
82705   int result;
82706
82707   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82708   jresult = (int)result;
82709   return jresult;
82710 }
82711
82712
82713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82714   int jresult ;
82715   int result;
82716
82717   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82718   jresult = (int)result;
82719   return jresult;
82720 }
82721
82722
82723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82724   int jresult ;
82725   int result;
82726
82727   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82728   jresult = (int)result;
82729   return jresult;
82730 }
82731
82732
82733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82734   void * jresult ;
82735   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82736
82737   {
82738     try {
82739       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82740     } catch (std::out_of_range& e) {
82741       {
82742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82743       };
82744     } catch (std::exception& e) {
82745       {
82746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82747       };
82748     } catch (Dali::DaliException e) {
82749       {
82750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82751       };
82752     } catch (...) {
82753       {
82754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82755       };
82756     }
82757   }
82758
82759   jresult = (void *)result;
82760   return jresult;
82761 }
82762
82763
82764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82765   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82766
82767   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82768   {
82769     try {
82770       delete arg1;
82771     } catch (std::out_of_range& e) {
82772       {
82773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82774       };
82775     } catch (std::exception& e) {
82776       {
82777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82778       };
82779     } catch (Dali::DaliException e) {
82780       {
82781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82782       };
82783     } catch (...) {
82784       {
82785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82786       };
82787     }
82788   }
82789
82790 }
82791
82792
82793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82794   void * jresult ;
82795   unsigned int arg1 ;
82796   unsigned int arg2 ;
82797   unsigned int arg3 ;
82798   unsigned int arg4 ;
82799   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82800
82801   arg1 = (unsigned int)jarg1;
82802   arg2 = (unsigned int)jarg2;
82803   arg3 = (unsigned int)jarg3;
82804   arg4 = (unsigned int)jarg4;
82805   {
82806     try {
82807       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82808     } catch (std::out_of_range& e) {
82809       {
82810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82811       };
82812     } catch (std::exception& e) {
82813       {
82814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82815       };
82816     } catch (Dali::DaliException e) {
82817       {
82818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82819       };
82820     } catch (...) {
82821       {
82822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82823       };
82824     }
82825   }
82826
82827   jresult = (void *)result;
82828   return jresult;
82829 }
82830
82831
82832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82833   void * jresult ;
82834   unsigned int arg1 ;
82835   unsigned int arg2 ;
82836   unsigned int arg3 ;
82837   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82838
82839   arg1 = (unsigned int)jarg1;
82840   arg2 = (unsigned int)jarg2;
82841   arg3 = (unsigned int)jarg3;
82842   {
82843     try {
82844       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82845     } catch (std::out_of_range& e) {
82846       {
82847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82848       };
82849     } catch (std::exception& e) {
82850       {
82851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82852       };
82853     } catch (Dali::DaliException e) {
82854       {
82855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82856       };
82857     } catch (...) {
82858       {
82859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82860       };
82861     }
82862   }
82863
82864   jresult = (void *)result;
82865   return jresult;
82866 }
82867
82868
82869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82870   void * jresult ;
82871   unsigned int arg1 ;
82872   unsigned int arg2 ;
82873   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82874
82875   arg1 = (unsigned int)jarg1;
82876   arg2 = (unsigned int)jarg2;
82877   {
82878     try {
82879       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82880     } catch (std::out_of_range& e) {
82881       {
82882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82883       };
82884     } catch (std::exception& e) {
82885       {
82886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82887       };
82888     } catch (Dali::DaliException e) {
82889       {
82890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82891       };
82892     } catch (...) {
82893       {
82894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82895       };
82896     }
82897   }
82898
82899   jresult = (void *)result;
82900   return jresult;
82901 }
82902
82903
82904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82905   void * jresult ;
82906   unsigned int arg1 ;
82907   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82908
82909   arg1 = (unsigned int)jarg1;
82910   {
82911     try {
82912       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82913     } catch (std::out_of_range& e) {
82914       {
82915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82916       };
82917     } catch (std::exception& e) {
82918       {
82919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82920       };
82921     } catch (Dali::DaliException e) {
82922       {
82923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82924       };
82925     } catch (...) {
82926       {
82927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82928       };
82929     }
82930   }
82931
82932   jresult = (void *)result;
82933   return jresult;
82934 }
82935
82936
82937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82938   void * jresult ;
82939   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82940
82941   {
82942     try {
82943       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82944     } catch (std::out_of_range& e) {
82945       {
82946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82947       };
82948     } catch (std::exception& e) {
82949       {
82950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82951       };
82952     } catch (Dali::DaliException e) {
82953       {
82954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82955       };
82956     } catch (...) {
82957       {
82958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82959       };
82960     }
82961   }
82962
82963   jresult = (void *)result;
82964   return jresult;
82965 }
82966
82967
82968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82969   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82970   unsigned int arg2 ;
82971
82972   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82973   arg2 = (unsigned int)jarg2;
82974   if (arg1) (arg1)->rowIndex = arg2;
82975 }
82976
82977
82978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82979   unsigned int jresult ;
82980   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82981   unsigned int result;
82982
82983   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82984   result = (unsigned int) ((arg1)->rowIndex);
82985   jresult = result;
82986   return jresult;
82987 }
82988
82989
82990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82991   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82992   unsigned int arg2 ;
82993
82994   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82995   arg2 = (unsigned int)jarg2;
82996   if (arg1) (arg1)->columnIndex = arg2;
82997 }
82998
82999
83000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
83001   unsigned int jresult ;
83002   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83003   unsigned int result;
83004
83005   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83006   result = (unsigned int) ((arg1)->columnIndex);
83007   jresult = result;
83008   return jresult;
83009 }
83010
83011
83012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
83013   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83014   unsigned int arg2 ;
83015
83016   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83017   arg2 = (unsigned int)jarg2;
83018   if (arg1) (arg1)->rowSpan = arg2;
83019 }
83020
83021
83022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
83023   unsigned int jresult ;
83024   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83025   unsigned int result;
83026
83027   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83028   result = (unsigned int) ((arg1)->rowSpan);
83029   jresult = result;
83030   return jresult;
83031 }
83032
83033
83034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
83035   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83036   unsigned int arg2 ;
83037
83038   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83039   arg2 = (unsigned int)jarg2;
83040   if (arg1) (arg1)->columnSpan = arg2;
83041 }
83042
83043
83044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
83045   unsigned int jresult ;
83046   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83047   unsigned int result;
83048
83049   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83050   result = (unsigned int) ((arg1)->columnSpan);
83051   jresult = result;
83052   return jresult;
83053 }
83054
83055
83056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
83057   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83058
83059   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83060   {
83061     try {
83062       delete arg1;
83063     } catch (std::out_of_range& e) {
83064       {
83065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83066       };
83067     } catch (std::exception& e) {
83068       {
83069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83070       };
83071     } catch (Dali::DaliException e) {
83072       {
83073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83074       };
83075     } catch (...) {
83076       {
83077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83078       };
83079     }
83080   }
83081
83082 }
83083
83084
83085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83086   void * jresult ;
83087   Dali::Toolkit::TableView *result = 0 ;
83088
83089   {
83090     try {
83091       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83092     } catch (std::out_of_range& e) {
83093       {
83094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83095       };
83096     } catch (std::exception& e) {
83097       {
83098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83099       };
83100     } catch (Dali::DaliException e) {
83101       {
83102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83103       };
83104     } catch (...) {
83105       {
83106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83107       };
83108     }
83109   }
83110
83111   jresult = (void *)result;
83112   return jresult;
83113 }
83114
83115
83116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83117   void * jresult ;
83118   Dali::Toolkit::TableView *arg1 = 0 ;
83119   Dali::Toolkit::TableView *result = 0 ;
83120
83121   arg1 = (Dali::Toolkit::TableView *)jarg1;
83122   if (!arg1) {
83123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83124     return 0;
83125   }
83126   {
83127     try {
83128       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83129     } catch (std::out_of_range& e) {
83130       {
83131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (std::exception& e) {
83134       {
83135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83136       };
83137     } catch (Dali::DaliException e) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83140       };
83141     } catch (...) {
83142       {
83143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83144       };
83145     }
83146   }
83147
83148   jresult = (void *)result;
83149   return jresult;
83150 }
83151
83152
83153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83154   void * jresult ;
83155   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83156   Dali::Toolkit::TableView *arg2 = 0 ;
83157   Dali::Toolkit::TableView *result = 0 ;
83158
83159   arg1 = (Dali::Toolkit::TableView *)jarg1;
83160   arg2 = (Dali::Toolkit::TableView *)jarg2;
83161   if (!arg2) {
83162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83163     return 0;
83164   }
83165   {
83166     try {
83167       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83168     } catch (std::out_of_range& e) {
83169       {
83170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83171       };
83172     } catch (std::exception& e) {
83173       {
83174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83175       };
83176     } catch (Dali::DaliException e) {
83177       {
83178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83179       };
83180     } catch (...) {
83181       {
83182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83183       };
83184     }
83185   }
83186
83187   jresult = (void *)result;
83188   return jresult;
83189 }
83190
83191
83192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83193   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83194
83195   arg1 = (Dali::Toolkit::TableView *)jarg1;
83196   {
83197     try {
83198       delete arg1;
83199     } catch (std::out_of_range& e) {
83200       {
83201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83202       };
83203     } catch (std::exception& e) {
83204       {
83205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83206       };
83207     } catch (Dali::DaliException e) {
83208       {
83209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83210       };
83211     } catch (...) {
83212       {
83213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83214       };
83215     }
83216   }
83217
83218 }
83219
83220
83221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83222   void * jresult ;
83223   unsigned int arg1 ;
83224   unsigned int arg2 ;
83225   Dali::Toolkit::TableView result;
83226
83227   arg1 = (unsigned int)jarg1;
83228   arg2 = (unsigned int)jarg2;
83229   {
83230     try {
83231       result = Dali::Toolkit::TableView::New(arg1,arg2);
83232     } catch (std::out_of_range& e) {
83233       {
83234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83235       };
83236     } catch (std::exception& e) {
83237       {
83238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83239       };
83240     } catch (Dali::DaliException e) {
83241       {
83242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83243       };
83244     } catch (...) {
83245       {
83246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83247       };
83248     }
83249   }
83250
83251   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83252   return jresult;
83253 }
83254
83255
83256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83257   void * jresult ;
83258   Dali::BaseHandle arg1 ;
83259   Dali::BaseHandle *argp1 ;
83260   Dali::Toolkit::TableView result;
83261
83262   argp1 = (Dali::BaseHandle *)jarg1;
83263   if (!argp1) {
83264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83265     return 0;
83266   }
83267   arg1 = *argp1;
83268   {
83269     try {
83270       result = Dali::Toolkit::TableView::DownCast(arg1);
83271     } catch (std::out_of_range& e) {
83272       {
83273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83274       };
83275     } catch (std::exception& e) {
83276       {
83277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83278       };
83279     } catch (Dali::DaliException e) {
83280       {
83281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83282       };
83283     } catch (...) {
83284       {
83285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83286       };
83287     }
83288   }
83289
83290   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83291   return jresult;
83292 }
83293
83294
83295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83296   unsigned int jresult ;
83297   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83298   Dali::Actor arg2 ;
83299   Dali::Toolkit::TableView::CellPosition arg3 ;
83300   Dali::Actor *argp2 ;
83301   Dali::Toolkit::TableView::CellPosition *argp3 ;
83302   bool result;
83303
83304   arg1 = (Dali::Toolkit::TableView *)jarg1;
83305   argp2 = (Dali::Actor *)jarg2;
83306   if (!argp2) {
83307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83308     return 0;
83309   }
83310   arg2 = *argp2;
83311   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83312   if (!argp3) {
83313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83314     return 0;
83315   }
83316   arg3 = *argp3;
83317   {
83318     try {
83319       result = (bool)(arg1)->AddChild(arg2,arg3);
83320     } catch (std::out_of_range& e) {
83321       {
83322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83323       };
83324     } catch (std::exception& e) {
83325       {
83326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83327       };
83328     } catch (Dali::DaliException e) {
83329       {
83330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83331       };
83332     } catch (...) {
83333       {
83334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83335       };
83336     }
83337   }
83338
83339   jresult = result;
83340   return jresult;
83341 }
83342
83343
83344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83345   void * jresult ;
83346   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83347   Dali::Toolkit::TableView::CellPosition arg2 ;
83348   Dali::Toolkit::TableView::CellPosition *argp2 ;
83349   Dali::Actor result;
83350
83351   arg1 = (Dali::Toolkit::TableView *)jarg1;
83352   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83353   if (!argp2) {
83354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83355     return 0;
83356   }
83357   arg2 = *argp2;
83358   {
83359     try {
83360       result = (arg1)->GetChildAt(arg2);
83361     } catch (std::out_of_range& e) {
83362       {
83363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83364       };
83365     } catch (std::exception& e) {
83366       {
83367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83368       };
83369     } catch (Dali::DaliException e) {
83370       {
83371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83372       };
83373     } catch (...) {
83374       {
83375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83376       };
83377     }
83378   }
83379
83380   jresult = new Dali::Actor((const Dali::Actor &)result);
83381   return jresult;
83382 }
83383
83384
83385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83386   void * jresult ;
83387   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83388   Dali::Toolkit::TableView::CellPosition arg2 ;
83389   Dali::Toolkit::TableView::CellPosition *argp2 ;
83390   Dali::Actor result;
83391
83392   arg1 = (Dali::Toolkit::TableView *)jarg1;
83393   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83394   if (!argp2) {
83395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83396     return 0;
83397   }
83398   arg2 = *argp2;
83399   {
83400     try {
83401       result = (arg1)->RemoveChildAt(arg2);
83402     } catch (std::out_of_range& e) {
83403       {
83404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83405       };
83406     } catch (std::exception& e) {
83407       {
83408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83409       };
83410     } catch (Dali::DaliException e) {
83411       {
83412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83413       };
83414     } catch (...) {
83415       {
83416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83417       };
83418     }
83419   }
83420
83421   jresult = new Dali::Actor((const Dali::Actor &)result);
83422   return jresult;
83423 }
83424
83425
83426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83427   unsigned int jresult ;
83428   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83429   Dali::Actor arg2 ;
83430   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83431   Dali::Actor *argp2 ;
83432   bool result;
83433
83434   arg1 = (Dali::Toolkit::TableView *)jarg1;
83435   argp2 = (Dali::Actor *)jarg2;
83436   if (!argp2) {
83437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83438     return 0;
83439   }
83440   arg2 = *argp2;
83441   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83442   if (!arg3) {
83443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83444     return 0;
83445   }
83446   {
83447     try {
83448       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83449     } catch (std::out_of_range& e) {
83450       {
83451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83452       };
83453     } catch (std::exception& e) {
83454       {
83455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83456       };
83457     } catch (Dali::DaliException e) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83460       };
83461     } catch (...) {
83462       {
83463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83464       };
83465     }
83466   }
83467
83468   jresult = result;
83469   return jresult;
83470 }
83471
83472
83473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83474   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83475   unsigned int arg2 ;
83476
83477   arg1 = (Dali::Toolkit::TableView *)jarg1;
83478   arg2 = (unsigned int)jarg2;
83479   {
83480     try {
83481       (arg1)->InsertRow(arg2);
83482     } catch (std::out_of_range& e) {
83483       {
83484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83485       };
83486     } catch (std::exception& e) {
83487       {
83488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83489       };
83490     } catch (Dali::DaliException e) {
83491       {
83492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83493       };
83494     } catch (...) {
83495       {
83496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83497       };
83498     }
83499   }
83500
83501 }
83502
83503
83504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83505   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83506   unsigned int arg2 ;
83507
83508   arg1 = (Dali::Toolkit::TableView *)jarg1;
83509   arg2 = (unsigned int)jarg2;
83510   {
83511     try {
83512       (arg1)->DeleteRow(arg2);
83513     } catch (std::out_of_range& e) {
83514       {
83515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83516       };
83517     } catch (std::exception& e) {
83518       {
83519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83520       };
83521     } catch (Dali::DaliException e) {
83522       {
83523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83524       };
83525     } catch (...) {
83526       {
83527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83528       };
83529     }
83530   }
83531
83532 }
83533
83534
83535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83536   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83537   unsigned int arg2 ;
83538   std::vector< Dali::Actor > *arg3 = 0 ;
83539
83540   arg1 = (Dali::Toolkit::TableView *)jarg1;
83541   arg2 = (unsigned int)jarg2;
83542   arg3 = (std::vector< Dali::Actor > *)jarg3;
83543   if (!arg3) {
83544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83545     return ;
83546   }
83547   {
83548     try {
83549       (arg1)->DeleteRow(arg2,*arg3);
83550     } catch (std::out_of_range& e) {
83551       {
83552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83553       };
83554     } catch (std::exception& e) {
83555       {
83556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83557       };
83558     } catch (Dali::DaliException e) {
83559       {
83560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83561       };
83562     } catch (...) {
83563       {
83564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83565       };
83566     }
83567   }
83568
83569 }
83570
83571
83572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83573   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83574   unsigned int arg2 ;
83575
83576   arg1 = (Dali::Toolkit::TableView *)jarg1;
83577   arg2 = (unsigned int)jarg2;
83578   {
83579     try {
83580       (arg1)->InsertColumn(arg2);
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83588       };
83589     } catch (Dali::DaliException e) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83596       };
83597     }
83598   }
83599
83600 }
83601
83602
83603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83604   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83605   unsigned int arg2 ;
83606
83607   arg1 = (Dali::Toolkit::TableView *)jarg1;
83608   arg2 = (unsigned int)jarg2;
83609   {
83610     try {
83611       (arg1)->DeleteColumn(arg2);
83612     } catch (std::out_of_range& e) {
83613       {
83614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83615       };
83616     } catch (std::exception& e) {
83617       {
83618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83619       };
83620     } catch (Dali::DaliException e) {
83621       {
83622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83623       };
83624     } catch (...) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83627       };
83628     }
83629   }
83630
83631 }
83632
83633
83634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83635   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83636   unsigned int arg2 ;
83637   std::vector< Dali::Actor > *arg3 = 0 ;
83638
83639   arg1 = (Dali::Toolkit::TableView *)jarg1;
83640   arg2 = (unsigned int)jarg2;
83641   arg3 = (std::vector< Dali::Actor > *)jarg3;
83642   if (!arg3) {
83643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83644     return ;
83645   }
83646   {
83647     try {
83648       (arg1)->DeleteColumn(arg2,*arg3);
83649     } catch (std::out_of_range& e) {
83650       {
83651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83652       };
83653     } catch (std::exception& e) {
83654       {
83655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83656       };
83657     } catch (Dali::DaliException e) {
83658       {
83659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83660       };
83661     } catch (...) {
83662       {
83663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83664       };
83665     }
83666   }
83667
83668 }
83669
83670
83671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83672   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83673   unsigned int arg2 ;
83674   unsigned int arg3 ;
83675
83676   arg1 = (Dali::Toolkit::TableView *)jarg1;
83677   arg2 = (unsigned int)jarg2;
83678   arg3 = (unsigned int)jarg3;
83679   {
83680     try {
83681       (arg1)->Resize(arg2,arg3);
83682     } catch (std::out_of_range& e) {
83683       {
83684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83685       };
83686     } catch (std::exception& e) {
83687       {
83688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83689       };
83690     } catch (Dali::DaliException e) {
83691       {
83692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83693       };
83694     } catch (...) {
83695       {
83696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83697       };
83698     }
83699   }
83700
83701 }
83702
83703
83704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83705   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83706   unsigned int arg2 ;
83707   unsigned int arg3 ;
83708   std::vector< Dali::Actor > *arg4 = 0 ;
83709
83710   arg1 = (Dali::Toolkit::TableView *)jarg1;
83711   arg2 = (unsigned int)jarg2;
83712   arg3 = (unsigned int)jarg3;
83713   arg4 = (std::vector< Dali::Actor > *)jarg4;
83714   if (!arg4) {
83715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83716     return ;
83717   }
83718   {
83719     try {
83720       (arg1)->Resize(arg2,arg3,*arg4);
83721     } catch (std::out_of_range& e) {
83722       {
83723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83724       };
83725     } catch (std::exception& e) {
83726       {
83727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83728       };
83729     } catch (Dali::DaliException e) {
83730       {
83731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83732       };
83733     } catch (...) {
83734       {
83735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83736       };
83737     }
83738   }
83739
83740 }
83741
83742
83743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83744   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83745   Dali::Size arg2 ;
83746   Dali::Size *argp2 ;
83747
83748   arg1 = (Dali::Toolkit::TableView *)jarg1;
83749   argp2 = (Dali::Size *)jarg2;
83750   if (!argp2) {
83751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83752     return ;
83753   }
83754   arg2 = *argp2;
83755   {
83756     try {
83757       (arg1)->SetCellPadding(arg2);
83758     } catch (std::out_of_range& e) {
83759       {
83760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83761       };
83762     } catch (std::exception& e) {
83763       {
83764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83765       };
83766     } catch (Dali::DaliException e) {
83767       {
83768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83769       };
83770     } catch (...) {
83771       {
83772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83773       };
83774     }
83775   }
83776
83777 }
83778
83779
83780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83781   void * jresult ;
83782   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83783   Dali::Size result;
83784
83785   arg1 = (Dali::Toolkit::TableView *)jarg1;
83786   {
83787     try {
83788       result = (arg1)->GetCellPadding();
83789     } catch (std::out_of_range& e) {
83790       {
83791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83792       };
83793     } catch (std::exception& e) {
83794       {
83795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83796       };
83797     } catch (Dali::DaliException e) {
83798       {
83799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83800       };
83801     } catch (...) {
83802       {
83803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83804       };
83805     }
83806   }
83807
83808   jresult = new Dali::Size((const Dali::Size &)result);
83809   return jresult;
83810 }
83811
83812
83813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83814   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83815   unsigned int arg2 ;
83816
83817   arg1 = (Dali::Toolkit::TableView *)jarg1;
83818   arg2 = (unsigned int)jarg2;
83819   {
83820     try {
83821       (arg1)->SetFitHeight(arg2);
83822     } catch (std::out_of_range& e) {
83823       {
83824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83825       };
83826     } catch (std::exception& e) {
83827       {
83828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83829       };
83830     } catch (Dali::DaliException e) {
83831       {
83832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83833       };
83834     } catch (...) {
83835       {
83836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83837       };
83838     }
83839   }
83840
83841 }
83842
83843
83844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83845   unsigned int jresult ;
83846   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83847   unsigned int arg2 ;
83848   bool result;
83849
83850   arg1 = (Dali::Toolkit::TableView *)jarg1;
83851   arg2 = (unsigned int)jarg2;
83852   {
83853     try {
83854       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83855     } catch (std::out_of_range& e) {
83856       {
83857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83858       };
83859     } catch (std::exception& e) {
83860       {
83861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83862       };
83863     } catch (Dali::DaliException e) {
83864       {
83865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83866       };
83867     } catch (...) {
83868       {
83869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83870       };
83871     }
83872   }
83873
83874   jresult = result;
83875   return jresult;
83876 }
83877
83878
83879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83880   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83881   unsigned int arg2 ;
83882
83883   arg1 = (Dali::Toolkit::TableView *)jarg1;
83884   arg2 = (unsigned int)jarg2;
83885   {
83886     try {
83887       (arg1)->SetFitWidth(arg2);
83888     } catch (std::out_of_range& e) {
83889       {
83890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83891       };
83892     } catch (std::exception& e) {
83893       {
83894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83895       };
83896     } catch (Dali::DaliException e) {
83897       {
83898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83899       };
83900     } catch (...) {
83901       {
83902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83903       };
83904     }
83905   }
83906
83907 }
83908
83909
83910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83911   unsigned int jresult ;
83912   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83913   unsigned int arg2 ;
83914   bool result;
83915
83916   arg1 = (Dali::Toolkit::TableView *)jarg1;
83917   arg2 = (unsigned int)jarg2;
83918   {
83919     try {
83920       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83921     } catch (std::out_of_range& e) {
83922       {
83923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83924       };
83925     } catch (std::exception& e) {
83926       {
83927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83928       };
83929     } catch (Dali::DaliException e) {
83930       {
83931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83932       };
83933     } catch (...) {
83934       {
83935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83936       };
83937     }
83938   }
83939
83940   jresult = result;
83941   return jresult;
83942 }
83943
83944
83945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83946   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83947   unsigned int arg2 ;
83948   float arg3 ;
83949
83950   arg1 = (Dali::Toolkit::TableView *)jarg1;
83951   arg2 = (unsigned int)jarg2;
83952   arg3 = (float)jarg3;
83953   {
83954     try {
83955       (arg1)->SetFixedHeight(arg2,arg3);
83956     } catch (std::out_of_range& e) {
83957       {
83958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83959       };
83960     } catch (std::exception& e) {
83961       {
83962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83963       };
83964     } catch (Dali::DaliException e) {
83965       {
83966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83967       };
83968     } catch (...) {
83969       {
83970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83971       };
83972     }
83973   }
83974
83975 }
83976
83977
83978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83979   float jresult ;
83980   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83981   unsigned int arg2 ;
83982   float result;
83983
83984   arg1 = (Dali::Toolkit::TableView *)jarg1;
83985   arg2 = (unsigned int)jarg2;
83986   {
83987     try {
83988       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83989     } catch (std::out_of_range& e) {
83990       {
83991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83992       };
83993     } catch (std::exception& e) {
83994       {
83995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83996       };
83997     } catch (Dali::DaliException e) {
83998       {
83999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84000       };
84001     } catch (...) {
84002       {
84003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84004       };
84005     }
84006   }
84007
84008   jresult = result;
84009   return jresult;
84010 }
84011
84012
84013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
84014   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84015   unsigned int arg2 ;
84016   float arg3 ;
84017
84018   arg1 = (Dali::Toolkit::TableView *)jarg1;
84019   arg2 = (unsigned int)jarg2;
84020   arg3 = (float)jarg3;
84021   {
84022     try {
84023       (arg1)->SetRelativeHeight(arg2,arg3);
84024     } catch (std::out_of_range& e) {
84025       {
84026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84027       };
84028     } catch (std::exception& e) {
84029       {
84030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84031       };
84032     } catch (Dali::DaliException e) {
84033       {
84034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84035       };
84036     } catch (...) {
84037       {
84038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84039       };
84040     }
84041   }
84042
84043 }
84044
84045
84046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
84047   float jresult ;
84048   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84049   unsigned int arg2 ;
84050   float result;
84051
84052   arg1 = (Dali::Toolkit::TableView *)jarg1;
84053   arg2 = (unsigned int)jarg2;
84054   {
84055     try {
84056       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
84057     } catch (std::out_of_range& e) {
84058       {
84059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84060       };
84061     } catch (std::exception& e) {
84062       {
84063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84064       };
84065     } catch (Dali::DaliException e) {
84066       {
84067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84068       };
84069     } catch (...) {
84070       {
84071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84072       };
84073     }
84074   }
84075
84076   jresult = result;
84077   return jresult;
84078 }
84079
84080
84081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84082   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84083   unsigned int arg2 ;
84084   float arg3 ;
84085
84086   arg1 = (Dali::Toolkit::TableView *)jarg1;
84087   arg2 = (unsigned int)jarg2;
84088   arg3 = (float)jarg3;
84089   {
84090     try {
84091       (arg1)->SetFixedWidth(arg2,arg3);
84092     } catch (std::out_of_range& e) {
84093       {
84094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84095       };
84096     } catch (std::exception& e) {
84097       {
84098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84099       };
84100     } catch (Dali::DaliException e) {
84101       {
84102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84103       };
84104     } catch (...) {
84105       {
84106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84107       };
84108     }
84109   }
84110
84111 }
84112
84113
84114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84115   float jresult ;
84116   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84117   unsigned int arg2 ;
84118   float result;
84119
84120   arg1 = (Dali::Toolkit::TableView *)jarg1;
84121   arg2 = (unsigned int)jarg2;
84122   {
84123     try {
84124       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84125     } catch (std::out_of_range& e) {
84126       {
84127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84128       };
84129     } catch (std::exception& e) {
84130       {
84131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84132       };
84133     } catch (Dali::DaliException e) {
84134       {
84135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84136       };
84137     } catch (...) {
84138       {
84139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84140       };
84141     }
84142   }
84143
84144   jresult = result;
84145   return jresult;
84146 }
84147
84148
84149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84150   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84151   unsigned int arg2 ;
84152   float arg3 ;
84153
84154   arg1 = (Dali::Toolkit::TableView *)jarg1;
84155   arg2 = (unsigned int)jarg2;
84156   arg3 = (float)jarg3;
84157   {
84158     try {
84159       (arg1)->SetRelativeWidth(arg2,arg3);
84160     } catch (std::out_of_range& e) {
84161       {
84162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84163       };
84164     } catch (std::exception& e) {
84165       {
84166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84167       };
84168     } catch (Dali::DaliException e) {
84169       {
84170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84171       };
84172     } catch (...) {
84173       {
84174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84175       };
84176     }
84177   }
84178
84179 }
84180
84181
84182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84183   float jresult ;
84184   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84185   unsigned int arg2 ;
84186   float result;
84187
84188   arg1 = (Dali::Toolkit::TableView *)jarg1;
84189   arg2 = (unsigned int)jarg2;
84190   {
84191     try {
84192       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84193     } catch (std::out_of_range& e) {
84194       {
84195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84196       };
84197     } catch (std::exception& e) {
84198       {
84199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84200       };
84201     } catch (Dali::DaliException e) {
84202       {
84203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84204       };
84205     } catch (...) {
84206       {
84207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84208       };
84209     }
84210   }
84211
84212   jresult = result;
84213   return jresult;
84214 }
84215
84216
84217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84218   unsigned int jresult ;
84219   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84220   unsigned int result;
84221
84222   arg1 = (Dali::Toolkit::TableView *)jarg1;
84223   {
84224     try {
84225       result = (unsigned int)(arg1)->GetRows();
84226     } catch (std::out_of_range& e) {
84227       {
84228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84229       };
84230     } catch (std::exception& e) {
84231       {
84232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84233       };
84234     } catch (Dali::DaliException e) {
84235       {
84236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84237       };
84238     } catch (...) {
84239       {
84240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84241       };
84242     }
84243   }
84244
84245   jresult = result;
84246   return jresult;
84247 }
84248
84249
84250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84251   unsigned int jresult ;
84252   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84253   unsigned int result;
84254
84255   arg1 = (Dali::Toolkit::TableView *)jarg1;
84256   {
84257     try {
84258       result = (unsigned int)(arg1)->GetColumns();
84259     } catch (std::out_of_range& e) {
84260       {
84261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84262       };
84263     } catch (std::exception& e) {
84264       {
84265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84266       };
84267     } catch (Dali::DaliException e) {
84268       {
84269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84270       };
84271     } catch (...) {
84272       {
84273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84274       };
84275     }
84276   }
84277
84278   jresult = result;
84279   return jresult;
84280 }
84281
84282
84283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84284   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84285   Dali::Toolkit::TableView::CellPosition arg2 ;
84286   Dali::HorizontalAlignment::Type arg3 ;
84287   Dali::VerticalAlignment::Type arg4 ;
84288   Dali::Toolkit::TableView::CellPosition *argp2 ;
84289
84290   arg1 = (Dali::Toolkit::TableView *)jarg1;
84291   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84292   if (!argp2) {
84293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84294     return ;
84295   }
84296   arg2 = *argp2;
84297   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84298   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84299   {
84300     try {
84301       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84302     } catch (std::out_of_range& e) {
84303       {
84304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84305       };
84306     } catch (std::exception& e) {
84307       {
84308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84309       };
84310     } catch (Dali::DaliException e) {
84311       {
84312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84313       };
84314     } catch (...) {
84315       {
84316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84317       };
84318     }
84319   }
84320
84321 }
84322
84323
84324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84325   unsigned int jresult ;
84326   unsigned int result;
84327
84328   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84329   jresult = result;
84330   return jresult;
84331 }
84332
84333
84334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84335   int jresult ;
84336   int result;
84337
84338   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84339   jresult = (int)result;
84340   return jresult;
84341 }
84342
84343
84344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84345   int jresult ;
84346   int result;
84347
84348   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84349   jresult = (int)result;
84350   return jresult;
84351 }
84352
84353
84354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84355   int jresult ;
84356   int result;
84357
84358   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84359   jresult = (int)result;
84360   return jresult;
84361 }
84362
84363
84364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84365   int jresult ;
84366   int result;
84367
84368   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84369   jresult = (int)result;
84370   return jresult;
84371 }
84372
84373
84374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84375   int jresult ;
84376   int result;
84377
84378   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84379   jresult = (int)result;
84380   return jresult;
84381 }
84382
84383
84384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84385   int jresult ;
84386   int result;
84387
84388   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84389   jresult = (int)result;
84390   return jresult;
84391 }
84392
84393
84394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84395   int jresult ;
84396   int result;
84397
84398   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84399   jresult = (int)result;
84400   return jresult;
84401 }
84402
84403
84404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84405   int jresult ;
84406   int result;
84407
84408   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84409   jresult = (int)result;
84410   return jresult;
84411 }
84412
84413
84414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84415   int jresult ;
84416   int result;
84417
84418   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84419   jresult = (int)result;
84420   return jresult;
84421 }
84422
84423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84424   int jresult ;
84425   int result;
84426
84427   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84428   jresult = (int)result;
84429   return jresult;
84430 }
84431
84432
84433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84434   int jresult ;
84435   int result;
84436
84437   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84438   jresult = (int)result;
84439   return jresult;
84440 }
84441
84442
84443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84444   int jresult ;
84445   int result;
84446
84447   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84448   jresult = (int)result;
84449   return jresult;
84450 }
84451
84452
84453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84454   int jresult ;
84455   int result;
84456
84457   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84458   jresult = (int)result;
84459   return jresult;
84460 }
84461
84462
84463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84464   int jresult ;
84465   int result;
84466
84467   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84468   jresult = (int)result;
84469   return jresult;
84470 }
84471
84472
84473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84474   int jresult ;
84475   int result;
84476
84477   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84478   jresult = (int)result;
84479   return jresult;
84480 }
84481
84482
84483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84484   int jresult ;
84485   int result;
84486
84487   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84488   jresult = (int)result;
84489   return jresult;
84490 }
84491
84492
84493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84494   int jresult ;
84495   int result;
84496
84497   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84498   jresult = (int)result;
84499   return jresult;
84500 }
84501
84502
84503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84504   int jresult ;
84505   int result;
84506
84507   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84508   jresult = (int)result;
84509   return jresult;
84510 }
84511
84512
84513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84514   int jresult ;
84515   int result;
84516
84517   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84518   jresult = (int)result;
84519   return jresult;
84520 }
84521
84522
84523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84524   int jresult ;
84525   int result;
84526
84527   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84528   jresult = (int)result;
84529   return jresult;
84530 }
84531
84532
84533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84534   int jresult ;
84535   int result;
84536
84537   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84538   jresult = (int)result;
84539   return jresult;
84540 }
84541
84542
84543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84544   int jresult ;
84545   int result;
84546
84547   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84548   jresult = (int)result;
84549   return jresult;
84550 }
84551
84552
84553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84554   int jresult ;
84555   int result;
84556
84557   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84558   jresult = (int)result;
84559   return jresult;
84560 }
84561
84562
84563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84564   int jresult ;
84565   int result;
84566
84567   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84568   jresult = (int)result;
84569   return jresult;
84570 }
84571
84572
84573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84574   void * jresult ;
84575   Dali::Toolkit::TextLabel::Property *result = 0 ;
84576
84577   {
84578     try {
84579       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84580     } catch (std::out_of_range& e) {
84581       {
84582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84583       };
84584     } catch (std::exception& e) {
84585       {
84586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84587       };
84588     } catch (Dali::DaliException e) {
84589       {
84590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84591       };
84592     } catch (...) {
84593       {
84594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84595       };
84596     }
84597   }
84598
84599   jresult = (void *)result;
84600   return jresult;
84601 }
84602
84603
84604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84605   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84606
84607   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84608   {
84609     try {
84610       delete arg1;
84611     } catch (std::out_of_range& e) {
84612       {
84613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84614       };
84615     } catch (std::exception& e) {
84616       {
84617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84618       };
84619     } catch (Dali::DaliException e) {
84620       {
84621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84622       };
84623     } catch (...) {
84624       {
84625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84626       };
84627     }
84628   }
84629
84630 }
84631
84632
84633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84634   void * jresult ;
84635   Dali::Toolkit::TextLabel result;
84636
84637   {
84638     try {
84639       result = Dali::Toolkit::TextLabel::New();
84640     } catch (std::out_of_range& e) {
84641       {
84642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84643       };
84644     } catch (std::exception& e) {
84645       {
84646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84647       };
84648     } catch (Dali::DaliException e) {
84649       {
84650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84651       };
84652     } catch (...) {
84653       {
84654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84655       };
84656     }
84657   }
84658
84659   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84660   return jresult;
84661 }
84662
84663
84664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84665   void * jresult ;
84666   std::string *arg1 = 0 ;
84667   Dali::Toolkit::TextLabel result;
84668
84669   if (!jarg1) {
84670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84671     return 0;
84672   }
84673   std::string arg1_str(jarg1);
84674   arg1 = &arg1_str;
84675   {
84676     try {
84677       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84678     } catch (std::out_of_range& e) {
84679       {
84680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84681       };
84682     } catch (std::exception& e) {
84683       {
84684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84685       };
84686     } catch (Dali::DaliException e) {
84687       {
84688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84689       };
84690     } catch (...) {
84691       {
84692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84693       };
84694     }
84695   }
84696
84697   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84698
84699   //argout typemap for const std::string&
84700
84701   return jresult;
84702 }
84703
84704
84705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84706   void * jresult ;
84707   Dali::Toolkit::TextLabel *result = 0 ;
84708
84709   {
84710     try {
84711       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84712     } catch (std::out_of_range& e) {
84713       {
84714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84715       };
84716     } catch (std::exception& e) {
84717       {
84718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84719       };
84720     } catch (Dali::DaliException e) {
84721       {
84722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84723       };
84724     } catch (...) {
84725       {
84726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84727       };
84728     }
84729   }
84730
84731   jresult = (void *)result;
84732   return jresult;
84733 }
84734
84735
84736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84737   void * jresult ;
84738   Dali::Toolkit::TextLabel *arg1 = 0 ;
84739   Dali::Toolkit::TextLabel *result = 0 ;
84740
84741   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84742   if (!arg1) {
84743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84744     return 0;
84745   }
84746   {
84747     try {
84748       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84749     } catch (std::out_of_range& e) {
84750       {
84751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84752       };
84753     } catch (std::exception& e) {
84754       {
84755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84756       };
84757     } catch (Dali::DaliException e) {
84758       {
84759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84760       };
84761     } catch (...) {
84762       {
84763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84764       };
84765     }
84766   }
84767
84768   jresult = (void *)result;
84769   return jresult;
84770 }
84771
84772
84773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84774   void * jresult ;
84775   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84776   Dali::Toolkit::TextLabel *arg2 = 0 ;
84777   Dali::Toolkit::TextLabel *result = 0 ;
84778
84779   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84780   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84781   if (!arg2) {
84782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84783     return 0;
84784   }
84785   {
84786     try {
84787       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84788     } catch (std::out_of_range& e) {
84789       {
84790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84791       };
84792     } catch (std::exception& e) {
84793       {
84794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84795       };
84796     } catch (Dali::DaliException e) {
84797       {
84798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84799       };
84800     } catch (...) {
84801       {
84802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84803       };
84804     }
84805   }
84806
84807   jresult = (void *)result;
84808   return jresult;
84809 }
84810
84811
84812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84813   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84814
84815   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84816   {
84817     try {
84818       delete arg1;
84819     } catch (std::out_of_range& e) {
84820       {
84821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84822       };
84823     } catch (std::exception& e) {
84824       {
84825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84826       };
84827     } catch (Dali::DaliException e) {
84828       {
84829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84830       };
84831     } catch (...) {
84832       {
84833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84834       };
84835     }
84836   }
84837
84838 }
84839
84840
84841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84842   void * jresult ;
84843   Dali::BaseHandle arg1 ;
84844   Dali::BaseHandle *argp1 ;
84845   Dali::Toolkit::TextLabel result;
84846
84847   argp1 = (Dali::BaseHandle *)jarg1;
84848   if (!argp1) {
84849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84850     return 0;
84851   }
84852   arg1 = *argp1;
84853   {
84854     try {
84855       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84856     } catch (std::out_of_range& e) {
84857       {
84858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84859       };
84860     } catch (std::exception& e) {
84861       {
84862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84863       };
84864     } catch (Dali::DaliException e) {
84865       {
84866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84867       };
84868     } catch (...) {
84869       {
84870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84871       };
84872     }
84873   }
84874
84875   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84876   return jresult;
84877 }
84878
84879
84880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84881   void * jresult ;
84882   Dali::Toolkit::AccessibilityManager *result = 0 ;
84883
84884   {
84885     try {
84886       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84887     } catch (std::out_of_range& e) {
84888       {
84889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84890       };
84891     } catch (std::exception& e) {
84892       {
84893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84894       };
84895     } catch (Dali::DaliException e) {
84896       {
84897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84898       };
84899     } catch (...) {
84900       {
84901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84902       };
84903     }
84904   }
84905
84906   jresult = (void *)result;
84907   return jresult;
84908 }
84909
84910
84911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84912   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84913
84914   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84915   {
84916     try {
84917       delete arg1;
84918     } catch (std::out_of_range& e) {
84919       {
84920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84921       };
84922     } catch (std::exception& e) {
84923       {
84924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84925       };
84926     } catch (Dali::DaliException e) {
84927       {
84928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84929       };
84930     } catch (...) {
84931       {
84932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84933       };
84934     }
84935   }
84936
84937 }
84938
84939
84940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84941   void * jresult ;
84942   Dali::Toolkit::AccessibilityManager result;
84943
84944   {
84945     try {
84946       result = Dali::Toolkit::AccessibilityManager::Get();
84947     } catch (std::out_of_range& e) {
84948       {
84949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84950       };
84951     } catch (std::exception& e) {
84952       {
84953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84954       };
84955     } catch (Dali::DaliException e) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84958       };
84959     } catch (...) {
84960       {
84961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84962       };
84963     }
84964   }
84965
84966   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84967   return jresult;
84968 }
84969
84970
84971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84972   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84973   Dali::Actor arg2 ;
84974   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84975   std::string *arg4 = 0 ;
84976   Dali::Actor *argp2 ;
84977
84978   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84979   argp2 = (Dali::Actor *)jarg2;
84980   if (!argp2) {
84981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84982     return ;
84983   }
84984   arg2 = *argp2;
84985   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84986   if (!jarg4) {
84987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84988     return ;
84989   }
84990   std::string arg4_str(jarg4);
84991   arg4 = &arg4_str;
84992   {
84993     try {
84994       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84995     } catch (std::out_of_range& e) {
84996       {
84997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84998       };
84999     } catch (std::exception& e) {
85000       {
85001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85002       };
85003     } catch (Dali::DaliException e) {
85004       {
85005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85006       };
85007     } catch (...) {
85008       {
85009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85010       };
85011     }
85012   }
85013
85014
85015   //argout typemap for const std::string&
85016
85017 }
85018
85019
85020 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
85021   char * jresult ;
85022   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85023   Dali::Actor arg2 ;
85024   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85025   Dali::Actor *argp2 ;
85026   std::string result;
85027
85028   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85029   argp2 = (Dali::Actor *)jarg2;
85030   if (!argp2) {
85031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85032     return 0;
85033   }
85034   arg2 = *argp2;
85035   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85036   {
85037     try {
85038       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
85039     } catch (std::out_of_range& e) {
85040       {
85041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85042       };
85043     } catch (std::exception& e) {
85044       {
85045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85046       };
85047     } catch (Dali::DaliException e) {
85048       {
85049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85050       };
85051     } catch (...) {
85052       {
85053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85054       };
85055     }
85056   }
85057
85058   jresult = SWIG_csharp_string_callback((&result)->c_str());
85059   return jresult;
85060 }
85061
85062
85063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
85064   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85065   Dali::Actor arg2 ;
85066   unsigned int arg3 ;
85067   Dali::Actor *argp2 ;
85068
85069   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85070   argp2 = (Dali::Actor *)jarg2;
85071   if (!argp2) {
85072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85073     return ;
85074   }
85075   arg2 = *argp2;
85076   arg3 = (unsigned int)jarg3;
85077   {
85078     try {
85079       (arg1)->SetFocusOrder(arg2,arg3);
85080     } catch (std::out_of_range& e) {
85081       {
85082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85083       };
85084     } catch (std::exception& e) {
85085       {
85086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85087       };
85088     } catch (Dali::DaliException e) {
85089       {
85090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85091       };
85092     } catch (...) {
85093       {
85094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85095       };
85096     }
85097   }
85098
85099 }
85100
85101
85102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85103   unsigned int jresult ;
85104   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85105   Dali::Actor arg2 ;
85106   Dali::Actor *argp2 ;
85107   unsigned int result;
85108
85109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85110   argp2 = (Dali::Actor *)jarg2;
85111   if (!argp2) {
85112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85113     return 0;
85114   }
85115   arg2 = *argp2;
85116   {
85117     try {
85118       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85119     } catch (std::out_of_range& e) {
85120       {
85121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85122       };
85123     } catch (std::exception& e) {
85124       {
85125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85126       };
85127     } catch (Dali::DaliException e) {
85128       {
85129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85130       };
85131     } catch (...) {
85132       {
85133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85134       };
85135     }
85136   }
85137
85138   jresult = result;
85139   return jresult;
85140 }
85141
85142
85143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85144   unsigned int jresult ;
85145   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85146   unsigned int result;
85147
85148   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85149   {
85150     try {
85151       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85152     } catch (std::out_of_range& e) {
85153       {
85154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85155       };
85156     } catch (std::exception& e) {
85157       {
85158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85159       };
85160     } catch (Dali::DaliException e) {
85161       {
85162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85163       };
85164     } catch (...) {
85165       {
85166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85167       };
85168     }
85169   }
85170
85171   jresult = result;
85172   return jresult;
85173 }
85174
85175
85176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85177   void * jresult ;
85178   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85179   unsigned int arg2 ;
85180   Dali::Actor result;
85181
85182   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85183   arg2 = (unsigned int)jarg2;
85184   {
85185     try {
85186       result = (arg1)->GetActorByFocusOrder(arg2);
85187     } catch (std::out_of_range& e) {
85188       {
85189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85190       };
85191     } catch (std::exception& e) {
85192       {
85193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85194       };
85195     } catch (Dali::DaliException e) {
85196       {
85197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85198       };
85199     } catch (...) {
85200       {
85201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85202       };
85203     }
85204   }
85205
85206   jresult = new Dali::Actor((const Dali::Actor &)result);
85207   return jresult;
85208 }
85209
85210
85211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85212   unsigned int jresult ;
85213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85214   Dali::Actor arg2 ;
85215   Dali::Actor *argp2 ;
85216   bool result;
85217
85218   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85219   argp2 = (Dali::Actor *)jarg2;
85220   if (!argp2) {
85221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85222     return 0;
85223   }
85224   arg2 = *argp2;
85225   {
85226     try {
85227       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85228     } catch (std::out_of_range& e) {
85229       {
85230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85231       };
85232     } catch (std::exception& e) {
85233       {
85234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85235       };
85236     } catch (Dali::DaliException e) {
85237       {
85238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85239       };
85240     } catch (...) {
85241       {
85242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85243       };
85244     }
85245   }
85246
85247   jresult = result;
85248   return jresult;
85249 }
85250
85251
85252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85253   void * jresult ;
85254   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85255   Dali::Actor result;
85256
85257   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85258   {
85259     try {
85260       result = (arg1)->GetCurrentFocusActor();
85261     } catch (std::out_of_range& e) {
85262       {
85263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85264       };
85265     } catch (std::exception& e) {
85266       {
85267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85268       };
85269     } catch (Dali::DaliException e) {
85270       {
85271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85272       };
85273     } catch (...) {
85274       {
85275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85276       };
85277     }
85278   }
85279
85280   jresult = new Dali::Actor((const Dali::Actor &)result);
85281   return jresult;
85282 }
85283
85284
85285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85286   void * jresult ;
85287   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85288   Dali::Actor result;
85289
85290   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85291   {
85292     try {
85293       result = (arg1)->GetCurrentFocusGroup();
85294     } catch (std::out_of_range& e) {
85295       {
85296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85297       };
85298     } catch (std::exception& e) {
85299       {
85300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85301       };
85302     } catch (Dali::DaliException e) {
85303       {
85304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85305       };
85306     } catch (...) {
85307       {
85308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85309       };
85310     }
85311   }
85312
85313   jresult = new Dali::Actor((const Dali::Actor &)result);
85314   return jresult;
85315 }
85316
85317
85318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85319   unsigned int jresult ;
85320   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85321   unsigned int result;
85322
85323   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85324   {
85325     try {
85326       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85327     } catch (std::out_of_range& e) {
85328       {
85329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85330       };
85331     } catch (std::exception& e) {
85332       {
85333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85334       };
85335     } catch (Dali::DaliException e) {
85336       {
85337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85338       };
85339     } catch (...) {
85340       {
85341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85342       };
85343     }
85344   }
85345
85346   jresult = result;
85347   return jresult;
85348 }
85349
85350
85351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85352   unsigned int jresult ;
85353   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85354   bool result;
85355
85356   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85357   {
85358     try {
85359       result = (bool)(arg1)->MoveFocusForward();
85360     } catch (std::out_of_range& e) {
85361       {
85362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85363       };
85364     } catch (std::exception& e) {
85365       {
85366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85367       };
85368     } catch (Dali::DaliException e) {
85369       {
85370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85371       };
85372     } catch (...) {
85373       {
85374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85375       };
85376     }
85377   }
85378
85379   jresult = result;
85380   return jresult;
85381 }
85382
85383
85384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85385   unsigned int jresult ;
85386   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85387   bool result;
85388
85389   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85390   {
85391     try {
85392       result = (bool)(arg1)->MoveFocusBackward();
85393     } catch (std::out_of_range& e) {
85394       {
85395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85396       };
85397     } catch (std::exception& e) {
85398       {
85399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85400       };
85401     } catch (Dali::DaliException e) {
85402       {
85403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85404       };
85405     } catch (...) {
85406       {
85407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85408       };
85409     }
85410   }
85411
85412   jresult = result;
85413   return jresult;
85414 }
85415
85416
85417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85419
85420   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85421   {
85422     try {
85423       (arg1)->ClearFocus();
85424     } catch (std::out_of_range& e) {
85425       {
85426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85427       };
85428     } catch (std::exception& e) {
85429       {
85430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85431       };
85432     } catch (Dali::DaliException e) {
85433       {
85434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85435       };
85436     } catch (...) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85439       };
85440     }
85441   }
85442
85443 }
85444
85445
85446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85448
85449   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85450   {
85451     try {
85452       (arg1)->Reset();
85453     } catch (std::out_of_range& e) {
85454       {
85455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85456       };
85457     } catch (std::exception& e) {
85458       {
85459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85460       };
85461     } catch (Dali::DaliException e) {
85462       {
85463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85464       };
85465     } catch (...) {
85466       {
85467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85468       };
85469     }
85470   }
85471
85472 }
85473
85474
85475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85476   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85477   Dali::Actor arg2 ;
85478   bool arg3 ;
85479   Dali::Actor *argp2 ;
85480
85481   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85482   argp2 = (Dali::Actor *)jarg2;
85483   if (!argp2) {
85484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85485     return ;
85486   }
85487   arg2 = *argp2;
85488   arg3 = jarg3 ? true : false;
85489   {
85490     try {
85491       (arg1)->SetFocusGroup(arg2,arg3);
85492     } catch (std::out_of_range& e) {
85493       {
85494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85495       };
85496     } catch (std::exception& e) {
85497       {
85498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85499       };
85500     } catch (Dali::DaliException e) {
85501       {
85502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85503       };
85504     } catch (...) {
85505       {
85506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85507       };
85508     }
85509   }
85510
85511 }
85512
85513
85514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85515   unsigned int jresult ;
85516   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85517   Dali::Actor arg2 ;
85518   Dali::Actor *argp2 ;
85519   bool result;
85520
85521   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85522   argp2 = (Dali::Actor *)jarg2;
85523   if (!argp2) {
85524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85525     return 0;
85526   }
85527   arg2 = *argp2;
85528   {
85529     try {
85530       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85531     } catch (std::out_of_range& e) {
85532       {
85533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85534       };
85535     } catch (std::exception& e) {
85536       {
85537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85538       };
85539     } catch (Dali::DaliException e) {
85540       {
85541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85542       };
85543     } catch (...) {
85544       {
85545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85546       };
85547     }
85548   }
85549
85550   jresult = result;
85551   return jresult;
85552 }
85553
85554
85555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85556   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85557   bool arg2 ;
85558
85559   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85560   arg2 = jarg2 ? true : false;
85561   {
85562     try {
85563       (arg1)->SetGroupMode(arg2);
85564     } catch (std::out_of_range& e) {
85565       {
85566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85567       };
85568     } catch (std::exception& e) {
85569       {
85570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85571       };
85572     } catch (Dali::DaliException e) {
85573       {
85574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85575       };
85576     } catch (...) {
85577       {
85578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85579       };
85580     }
85581   }
85582
85583 }
85584
85585
85586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85587   unsigned int jresult ;
85588   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85589   bool result;
85590
85591   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85592   {
85593     try {
85594       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85595     } catch (std::out_of_range& e) {
85596       {
85597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85598       };
85599     } catch (std::exception& e) {
85600       {
85601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85602       };
85603     } catch (Dali::DaliException e) {
85604       {
85605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85606       };
85607     } catch (...) {
85608       {
85609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85610       };
85611     }
85612   }
85613
85614   jresult = result;
85615   return jresult;
85616 }
85617
85618
85619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85620   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85621   bool arg2 ;
85622
85623   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85624   arg2 = jarg2 ? true : false;
85625   {
85626     try {
85627       (arg1)->SetWrapMode(arg2);
85628     } catch (std::out_of_range& e) {
85629       {
85630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85631       };
85632     } catch (std::exception& e) {
85633       {
85634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85635       };
85636     } catch (Dali::DaliException e) {
85637       {
85638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85639       };
85640     } catch (...) {
85641       {
85642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85643       };
85644     }
85645   }
85646
85647 }
85648
85649
85650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85651   unsigned int jresult ;
85652   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85653   bool result;
85654
85655   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85656   {
85657     try {
85658       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85659     } catch (std::out_of_range& e) {
85660       {
85661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85662       };
85663     } catch (std::exception& e) {
85664       {
85665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85666       };
85667     } catch (Dali::DaliException e) {
85668       {
85669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85670       };
85671     } catch (...) {
85672       {
85673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85674       };
85675     }
85676   }
85677
85678   jresult = result;
85679   return jresult;
85680 }
85681
85682
85683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85684   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85685   Dali::Actor arg2 ;
85686   Dali::Actor *argp2 ;
85687
85688   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85689   argp2 = (Dali::Actor *)jarg2;
85690   if (!argp2) {
85691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85692     return ;
85693   }
85694   arg2 = *argp2;
85695   {
85696     try {
85697       (arg1)->SetFocusIndicatorActor(arg2);
85698     } catch (std::out_of_range& e) {
85699       {
85700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85701       };
85702     } catch (std::exception& e) {
85703       {
85704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85705       };
85706     } catch (Dali::DaliException e) {
85707       {
85708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85709       };
85710     } catch (...) {
85711       {
85712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85713       };
85714     }
85715   }
85716
85717 }
85718
85719
85720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85721   void * jresult ;
85722   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85723   Dali::Actor result;
85724
85725   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85726   {
85727     try {
85728       result = (arg1)->GetFocusIndicatorActor();
85729     } catch (std::out_of_range& e) {
85730       {
85731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85732       };
85733     } catch (std::exception& e) {
85734       {
85735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85736       };
85737     } catch (Dali::DaliException e) {
85738       {
85739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85740       };
85741     } catch (...) {
85742       {
85743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85744       };
85745     }
85746   }
85747
85748   jresult = new Dali::Actor((const Dali::Actor &)result);
85749   return jresult;
85750 }
85751
85752
85753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85754   void * jresult ;
85755   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85756   Dali::Actor arg2 ;
85757   Dali::Actor *argp2 ;
85758   Dali::Actor result;
85759
85760   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85761   argp2 = (Dali::Actor *)jarg2;
85762   if (!argp2) {
85763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85764     return 0;
85765   }
85766   arg2 = *argp2;
85767   {
85768     try {
85769       result = (arg1)->GetFocusGroup(arg2);
85770     } catch (std::out_of_range& e) {
85771       {
85772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85773       };
85774     } catch (std::exception& e) {
85775       {
85776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85777       };
85778     } catch (Dali::DaliException e) {
85779       {
85780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85781       };
85782     } catch (...) {
85783       {
85784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85785       };
85786     }
85787   }
85788
85789   jresult = new Dali::Actor((const Dali::Actor &)result);
85790   return jresult;
85791 }
85792
85793
85794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85795   void * jresult ;
85796   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85797   Dali::Vector2 result;
85798
85799   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85800   {
85801     try {
85802       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85803     } catch (std::out_of_range& e) {
85804       {
85805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85806       };
85807     } catch (std::exception& e) {
85808       {
85809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85810       };
85811     } catch (Dali::DaliException e) {
85812       {
85813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85814       };
85815     } catch (...) {
85816       {
85817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85818       };
85819     }
85820   }
85821
85822   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85823   return jresult;
85824 }
85825
85826
85827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85828   void * jresult ;
85829   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85830   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85831
85832   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85833   {
85834     try {
85835       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85836     } catch (std::out_of_range& e) {
85837       {
85838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85839       };
85840     } catch (std::exception& e) {
85841       {
85842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85843       };
85844     } catch (Dali::DaliException e) {
85845       {
85846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85847       };
85848     } catch (...) {
85849       {
85850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85851       };
85852     }
85853   }
85854
85855   jresult = (void *)result;
85856   return jresult;
85857 }
85858
85859
85860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85861   void * jresult ;
85862   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85863   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85864
85865   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85866   {
85867     try {
85868       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85869     } catch (std::out_of_range& e) {
85870       {
85871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85872       };
85873     } catch (std::exception& e) {
85874       {
85875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85876       };
85877     } catch (Dali::DaliException e) {
85878       {
85879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85880       };
85881     } catch (...) {
85882       {
85883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85884       };
85885     }
85886   }
85887
85888   jresult = (void *)result;
85889   return jresult;
85890 }
85891
85892
85893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85894   void * jresult ;
85895   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85896   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85897
85898   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85899   {
85900     try {
85901       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85902     } catch (std::out_of_range& e) {
85903       {
85904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85905       };
85906     } catch (std::exception& e) {
85907       {
85908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85909       };
85910     } catch (Dali::DaliException e) {
85911       {
85912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85913       };
85914     } catch (...) {
85915       {
85916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85917       };
85918     }
85919   }
85920
85921   jresult = (void *)result;
85922   return jresult;
85923 }
85924
85925
85926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85927   void * jresult ;
85928   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85929   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85930
85931   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85932   {
85933     try {
85934       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85935     } catch (std::out_of_range& e) {
85936       {
85937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85938       };
85939     } catch (std::exception& e) {
85940       {
85941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85942       };
85943     } catch (Dali::DaliException e) {
85944       {
85945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85946       };
85947     } catch (...) {
85948       {
85949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85950       };
85951     }
85952   }
85953
85954   jresult = (void *)result;
85955   return jresult;
85956 }
85957
85958
85959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85960   void * jresult ;
85961   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85962   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85963
85964   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85965   {
85966     try {
85967       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85968     } catch (std::out_of_range& e) {
85969       {
85970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85971       };
85972     } catch (std::exception& e) {
85973       {
85974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85975       };
85976     } catch (Dali::DaliException e) {
85977       {
85978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85979       };
85980     } catch (...) {
85981       {
85982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85983       };
85984     }
85985   }
85986
85987   jresult = (void *)result;
85988   return jresult;
85989 }
85990
85991
85992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85993   void * jresult ;
85994   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85995   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85996
85997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85998   {
85999     try {
86000       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
86001     } catch (std::out_of_range& e) {
86002       {
86003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86004       };
86005     } catch (std::exception& e) {
86006       {
86007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86008       };
86009     } catch (Dali::DaliException e) {
86010       {
86011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86012       };
86013     } catch (...) {
86014       {
86015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86016       };
86017     }
86018   }
86019
86020   jresult = (void *)result;
86021   return jresult;
86022 }
86023
86024
86025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
86026   void * jresult ;
86027   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86028   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86029
86030   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86031   {
86032     try {
86033       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
86034     } catch (std::out_of_range& e) {
86035       {
86036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86037       };
86038     } catch (std::exception& e) {
86039       {
86040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86041       };
86042     } catch (Dali::DaliException e) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86045       };
86046     } catch (...) {
86047       {
86048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86049       };
86050     }
86051   }
86052
86053   jresult = (void *)result;
86054   return jresult;
86055 }
86056
86057
86058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
86059   void * jresult ;
86060   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86061   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86062
86063   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86064   {
86065     try {
86066       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
86067     } catch (std::out_of_range& e) {
86068       {
86069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86070       };
86071     } catch (std::exception& e) {
86072       {
86073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86074       };
86075     } catch (Dali::DaliException e) {
86076       {
86077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86078       };
86079     } catch (...) {
86080       {
86081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86082       };
86083     }
86084   }
86085
86086   jresult = (void *)result;
86087   return jresult;
86088 }
86089
86090
86091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86092   void * jresult ;
86093   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86094   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86095
86096   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86097   {
86098     try {
86099       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86100     } catch (std::out_of_range& e) {
86101       {
86102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86103       };
86104     } catch (std::exception& e) {
86105       {
86106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86107       };
86108     } catch (Dali::DaliException e) {
86109       {
86110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86111       };
86112     } catch (...) {
86113       {
86114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86115       };
86116     }
86117   }
86118
86119   jresult = (void *)result;
86120   return jresult;
86121 }
86122
86123
86124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86125   void * jresult ;
86126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86127   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86128
86129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86130   {
86131     try {
86132       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86133     } catch (std::out_of_range& e) {
86134       {
86135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86136       };
86137     } catch (std::exception& e) {
86138       {
86139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86140       };
86141     } catch (Dali::DaliException e) {
86142       {
86143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86144       };
86145     } catch (...) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86148       };
86149     }
86150   }
86151
86152   jresult = (void *)result;
86153   return jresult;
86154 }
86155
86156
86157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86158   void * jresult ;
86159   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86160   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86161
86162   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86163   {
86164     try {
86165       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86166     } catch (std::out_of_range& e) {
86167       {
86168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (std::exception& e) {
86171       {
86172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86173       };
86174     } catch (Dali::DaliException e) {
86175       {
86176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86177       };
86178     } catch (...) {
86179       {
86180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86181       };
86182     }
86183   }
86184
86185   jresult = (void *)result;
86186   return jresult;
86187 }
86188
86189
86190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86191   void * jresult ;
86192   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86193   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86194
86195   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86196   {
86197     try {
86198       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86199     } catch (std::out_of_range& e) {
86200       {
86201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86202       };
86203     } catch (std::exception& e) {
86204       {
86205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86206       };
86207     } catch (Dali::DaliException e) {
86208       {
86209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86210       };
86211     } catch (...) {
86212       {
86213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86214       };
86215     }
86216   }
86217
86218   jresult = (void *)result;
86219   return jresult;
86220 }
86221
86222
86223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86224   void * jresult ;
86225   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86226   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86227
86228   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86229   {
86230     try {
86231       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86232     } catch (std::out_of_range& e) {
86233       {
86234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86235       };
86236     } catch (std::exception& e) {
86237       {
86238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86239       };
86240     } catch (Dali::DaliException e) {
86241       {
86242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86243       };
86244     } catch (...) {
86245       {
86246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86247       };
86248     }
86249   }
86250
86251   jresult = (void *)result;
86252   return jresult;
86253 }
86254
86255
86256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86257   void * jresult ;
86258   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86259   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86260
86261   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86262   {
86263     try {
86264       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86265     } catch (std::out_of_range& e) {
86266       {
86267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86268       };
86269     } catch (std::exception& e) {
86270       {
86271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86272       };
86273     } catch (Dali::DaliException e) {
86274       {
86275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86276       };
86277     } catch (...) {
86278       {
86279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86280       };
86281     }
86282   }
86283
86284   jresult = (void *)result;
86285   return jresult;
86286 }
86287
86288
86289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86290   void * jresult ;
86291   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86292   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86293
86294   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86295   {
86296     try {
86297       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86298     } catch (std::out_of_range& e) {
86299       {
86300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86301       };
86302     } catch (std::exception& e) {
86303       {
86304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86305       };
86306     } catch (Dali::DaliException e) {
86307       {
86308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86309       };
86310     } catch (...) {
86311       {
86312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86313       };
86314     }
86315   }
86316
86317   jresult = (void *)result;
86318   return jresult;
86319 }
86320
86321
86322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86323   void * jresult ;
86324   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86325   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86326
86327   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86328   {
86329     try {
86330       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86331     } catch (std::out_of_range& e) {
86332       {
86333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86334       };
86335     } catch (std::exception& e) {
86336       {
86337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86338       };
86339     } catch (Dali::DaliException e) {
86340       {
86341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86342       };
86343     } catch (...) {
86344       {
86345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86346       };
86347     }
86348   }
86349
86350   jresult = (void *)result;
86351   return jresult;
86352 }
86353
86354
86355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86356   void * jresult ;
86357   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86358   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86359
86360   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86361   {
86362     try {
86363       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86364     } catch (std::out_of_range& e) {
86365       {
86366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86367       };
86368     } catch (std::exception& e) {
86369       {
86370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86371       };
86372     } catch (Dali::DaliException e) {
86373       {
86374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86375       };
86376     } catch (...) {
86377       {
86378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86379       };
86380     }
86381   }
86382
86383   jresult = (void *)result;
86384   return jresult;
86385 }
86386
86387
86388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86389   void * jresult ;
86390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86391   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86392
86393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86394   {
86395     try {
86396       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86397     } catch (std::out_of_range& e) {
86398       {
86399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86400       };
86401     } catch (std::exception& e) {
86402       {
86403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86404       };
86405     } catch (Dali::DaliException e) {
86406       {
86407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86408       };
86409     } catch (...) {
86410       {
86411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86412       };
86413     }
86414   }
86415
86416   jresult = (void *)result;
86417   return jresult;
86418 }
86419
86420
86421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86422   void * jresult ;
86423   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86424   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86425
86426   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86427   {
86428     try {
86429       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86430     } catch (std::out_of_range& e) {
86431       {
86432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86433       };
86434     } catch (std::exception& e) {
86435       {
86436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86437       };
86438     } catch (Dali::DaliException e) {
86439       {
86440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86441       };
86442     } catch (...) {
86443       {
86444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86445       };
86446     }
86447   }
86448
86449   jresult = (void *)result;
86450   return jresult;
86451 }
86452
86453
86454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86455   void * jresult ;
86456   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86457   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86458
86459   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86460   {
86461     try {
86462       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86463     } catch (std::out_of_range& e) {
86464       {
86465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86466       };
86467     } catch (std::exception& e) {
86468       {
86469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86470       };
86471     } catch (Dali::DaliException e) {
86472       {
86473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86474       };
86475     } catch (...) {
86476       {
86477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86478       };
86479     }
86480   }
86481
86482   jresult = (void *)result;
86483   return jresult;
86484 }
86485
86486
86487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86488   void * jresult ;
86489   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86490   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86491
86492   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86493   {
86494     try {
86495       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86496     } catch (std::out_of_range& e) {
86497       {
86498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86499       };
86500     } catch (std::exception& e) {
86501       {
86502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86503       };
86504     } catch (Dali::DaliException e) {
86505       {
86506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86507       };
86508     } catch (...) {
86509       {
86510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86511       };
86512     }
86513   }
86514
86515   jresult = (void *)result;
86516   return jresult;
86517 }
86518
86519
86520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86521   void * jresult ;
86522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86523   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86524
86525   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86526   {
86527     try {
86528       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86529     } catch (std::out_of_range& e) {
86530       {
86531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86532       };
86533     } catch (std::exception& e) {
86534       {
86535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86536       };
86537     } catch (Dali::DaliException e) {
86538       {
86539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86540       };
86541     } catch (...) {
86542       {
86543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86544       };
86545     }
86546   }
86547
86548   jresult = (void *)result;
86549   return jresult;
86550 }
86551
86552
86553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86554   void * jresult ;
86555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86556   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86557
86558   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86559   {
86560     try {
86561       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86562     } catch (std::out_of_range& e) {
86563       {
86564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86565       };
86566     } catch (std::exception& e) {
86567       {
86568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86569       };
86570     } catch (Dali::DaliException e) {
86571       {
86572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86573       };
86574     } catch (...) {
86575       {
86576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86577       };
86578     }
86579   }
86580
86581   jresult = (void *)result;
86582   return jresult;
86583 }
86584
86585
86586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86587   void * jresult ;
86588   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86589   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86590
86591   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86592   {
86593     try {
86594       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86595     } catch (std::out_of_range& e) {
86596       {
86597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86598       };
86599     } catch (std::exception& e) {
86600       {
86601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86602       };
86603     } catch (Dali::DaliException e) {
86604       {
86605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86606       };
86607     } catch (...) {
86608       {
86609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86610       };
86611     }
86612   }
86613
86614   jresult = (void *)result;
86615   return jresult;
86616 }
86617
86618
86619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86620   void * jresult ;
86621   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86622   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86623
86624   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86625   {
86626     try {
86627       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86628     } catch (std::out_of_range& e) {
86629       {
86630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86631       };
86632     } catch (std::exception& e) {
86633       {
86634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86635       };
86636     } catch (Dali::DaliException e) {
86637       {
86638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86639       };
86640     } catch (...) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86643       };
86644     }
86645   }
86646
86647   jresult = (void *)result;
86648   return jresult;
86649 }
86650
86651
86652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86653   void * jresult ;
86654   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86655   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86656
86657   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86658   {
86659     try {
86660       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86661     } catch (std::out_of_range& e) {
86662       {
86663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86664       };
86665     } catch (std::exception& e) {
86666       {
86667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86668       };
86669     } catch (Dali::DaliException e) {
86670       {
86671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86672       };
86673     } catch (...) {
86674       {
86675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86676       };
86677     }
86678   }
86679
86680   jresult = (void *)result;
86681   return jresult;
86682 }
86683
86684
86685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86686   void * jresult ;
86687   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86688   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86689
86690   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86691   {
86692     try {
86693       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86694     } catch (std::out_of_range& e) {
86695       {
86696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86697       };
86698     } catch (std::exception& e) {
86699       {
86700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86701       };
86702     } catch (Dali::DaliException e) {
86703       {
86704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86705       };
86706     } catch (...) {
86707       {
86708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86709       };
86710     }
86711   }
86712
86713   jresult = (void *)result;
86714   return jresult;
86715 }
86716
86717
86718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86719   void * jresult ;
86720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86721   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86722
86723   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86724   {
86725     try {
86726       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86727     } catch (std::out_of_range& e) {
86728       {
86729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86730       };
86731     } catch (std::exception& e) {
86732       {
86733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86734       };
86735     } catch (Dali::DaliException e) {
86736       {
86737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86738       };
86739     } catch (...) {
86740       {
86741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86742       };
86743     }
86744   }
86745
86746   jresult = (void *)result;
86747   return jresult;
86748 }
86749
86750
86751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86752   void * jresult ;
86753   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86754   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86755
86756   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86757   {
86758     try {
86759       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86760     } catch (std::out_of_range& e) {
86761       {
86762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86763       };
86764     } catch (std::exception& e) {
86765       {
86766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86767       };
86768     } catch (Dali::DaliException e) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86771       };
86772     } catch (...) {
86773       {
86774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86775       };
86776     }
86777   }
86778
86779   jresult = (void *)result;
86780   return jresult;
86781 }
86782
86783
86784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86785   void * jresult ;
86786   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86787   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86788
86789   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86790   {
86791     try {
86792       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86793     } catch (std::out_of_range& e) {
86794       {
86795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86796       };
86797     } catch (std::exception& e) {
86798       {
86799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86800       };
86801     } catch (Dali::DaliException e) {
86802       {
86803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86804       };
86805     } catch (...) {
86806       {
86807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86808       };
86809     }
86810   }
86811
86812   jresult = (void *)result;
86813   return jresult;
86814 }
86815
86816
86817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86818   void * jresult ;
86819   Dali::Toolkit::StyleManager *result = 0 ;
86820
86821   {
86822     try {
86823       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86824     } catch (std::out_of_range& e) {
86825       {
86826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86827       };
86828     } catch (std::exception& e) {
86829       {
86830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86831       };
86832     } catch (Dali::DaliException e) {
86833       {
86834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86835       };
86836     } catch (...) {
86837       {
86838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86839       };
86840     }
86841   }
86842
86843   jresult = (void *)result;
86844   return jresult;
86845 }
86846
86847
86848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86849   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86850
86851   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86852   {
86853     try {
86854       delete arg1;
86855     } catch (std::out_of_range& e) {
86856       {
86857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86858       };
86859     } catch (std::exception& e) {
86860       {
86861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86862       };
86863     } catch (Dali::DaliException e) {
86864       {
86865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86866       };
86867     } catch (...) {
86868       {
86869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86870       };
86871     }
86872   }
86873
86874 }
86875
86876
86877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86878   void * jresult ;
86879   Dali::Toolkit::StyleManager result;
86880
86881   {
86882     try {
86883       result = Dali::Toolkit::StyleManager::Get();
86884     } catch (std::out_of_range& e) {
86885       {
86886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86887       };
86888     } catch (std::exception& e) {
86889       {
86890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86891       };
86892     } catch (Dali::DaliException e) {
86893       {
86894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86895       };
86896     } catch (...) {
86897       {
86898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86899       };
86900     }
86901   }
86902
86903   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86904   return jresult;
86905 }
86906
86907
86908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86909   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86910   std::string *arg2 = 0 ;
86911
86912   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86913   if (!jarg2) {
86914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86915     return ;
86916   }
86917   std::string arg2_str(jarg2);
86918   arg2 = &arg2_str;
86919   {
86920     try {
86921       (arg1)->ApplyTheme((std::string const &)*arg2);
86922     } catch (std::out_of_range& e) {
86923       {
86924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86925       };
86926     } catch (std::exception& e) {
86927       {
86928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86929       };
86930     } catch (Dali::DaliException e) {
86931       {
86932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86933       };
86934     } catch (...) {
86935       {
86936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86937       };
86938     }
86939   }
86940
86941
86942   //argout typemap for const std::string&
86943
86944 }
86945
86946
86947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86948   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86949
86950   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86951   {
86952     try {
86953       (arg1)->ApplyDefaultTheme();
86954     } catch (std::out_of_range& e) {
86955       {
86956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86957       };
86958     } catch (std::exception& e) {
86959       {
86960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86961       };
86962     } catch (Dali::DaliException e) {
86963       {
86964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86965       };
86966     } catch (...) {
86967       {
86968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86969       };
86970     }
86971   }
86972
86973 }
86974
86975
86976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86977   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86978   std::string *arg2 = 0 ;
86979   Dali::Property::Value *arg3 = 0 ;
86980
86981   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86982   if (!jarg2) {
86983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86984     return ;
86985   }
86986   std::string arg2_str(jarg2);
86987   arg2 = &arg2_str;
86988   arg3 = (Dali::Property::Value *)jarg3;
86989   if (!arg3) {
86990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86991     return ;
86992   }
86993   {
86994     try {
86995       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86996     } catch (std::out_of_range& e) {
86997       {
86998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86999       };
87000     } catch (std::exception& e) {
87001       {
87002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87003       };
87004     } catch (Dali::DaliException e) {
87005       {
87006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87007       };
87008     } catch (...) {
87009       {
87010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87011       };
87012     }
87013   }
87014
87015
87016   //argout typemap for const std::string&
87017
87018 }
87019
87020
87021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87022   unsigned int jresult ;
87023   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87024   std::string *arg2 = 0 ;
87025   Dali::Property::Value *arg3 = 0 ;
87026   bool result;
87027
87028   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87029   if (!jarg2) {
87030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87031     return 0;
87032   }
87033   std::string arg2_str(jarg2);
87034   arg2 = &arg2_str;
87035   arg3 = (Dali::Property::Value *)jarg3;
87036   if (!arg3) {
87037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
87038     return 0;
87039   }
87040   {
87041     try {
87042       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
87043     } catch (std::out_of_range& e) {
87044       {
87045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87046       };
87047     } catch (std::exception& e) {
87048       {
87049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87050       };
87051     } catch (Dali::DaliException e) {
87052       {
87053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87054       };
87055     } catch (...) {
87056       {
87057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87058       };
87059     }
87060   }
87061
87062   jresult = result;
87063
87064   //argout typemap for const std::string&
87065
87066   return jresult;
87067 }
87068
87069
87070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
87071   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87072   Dali::Toolkit::Control arg2 ;
87073   std::string *arg3 = 0 ;
87074   std::string *arg4 = 0 ;
87075   Dali::Toolkit::Control *argp2 ;
87076
87077   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87078   argp2 = (Dali::Toolkit::Control *)jarg2;
87079   if (!argp2) {
87080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87081     return ;
87082   }
87083   arg2 = *argp2;
87084   if (!jarg3) {
87085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87086     return ;
87087   }
87088   std::string arg3_str(jarg3);
87089   arg3 = &arg3_str;
87090   if (!jarg4) {
87091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87092     return ;
87093   }
87094   std::string arg4_str(jarg4);
87095   arg4 = &arg4_str;
87096   {
87097     try {
87098       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87099     } catch (std::out_of_range& e) {
87100       {
87101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87102       };
87103     } catch (std::exception& e) {
87104       {
87105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87106       };
87107     } catch (Dali::DaliException e) {
87108       {
87109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87110       };
87111     } catch (...) {
87112       {
87113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87114       };
87115     }
87116   }
87117
87118
87119   //argout typemap for const std::string&
87120
87121
87122   //argout typemap for const std::string&
87123
87124 }
87125
87126
87127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87128   void * jresult ;
87129   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87130   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87131
87132   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87133   {
87134     try {
87135       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87136     } catch (std::out_of_range& e) {
87137       {
87138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87139       };
87140     } catch (std::exception& e) {
87141       {
87142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87143       };
87144     } catch (Dali::DaliException e) {
87145       {
87146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87147       };
87148     } catch (...) {
87149       {
87150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87151       };
87152     }
87153   }
87154
87155   jresult = (void *)result;
87156   return jresult;
87157 }
87158
87159
87160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87161   int jresult ;
87162   int result;
87163
87164   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87165   jresult = (int)result;
87166   return jresult;
87167 }
87168
87169
87170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87171   int jresult ;
87172   int result;
87173
87174   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87175   jresult = (int)result;
87176   return jresult;
87177 }
87178
87179
87180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87181   int jresult ;
87182   int result;
87183
87184   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87185   jresult = (int)result;
87186   return jresult;
87187 }
87188
87189
87190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87191   int jresult ;
87192   int result;
87193
87194   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87195   jresult = (int)result;
87196   return jresult;
87197 }
87198
87199
87200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87201   int jresult ;
87202   int result;
87203
87204   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87205   jresult = (int)result;
87206   return jresult;
87207 }
87208
87209
87210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87211   int jresult ;
87212   int result;
87213
87214   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87215   jresult = (int)result;
87216   return jresult;
87217 }
87218
87219
87220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87221   int jresult ;
87222   int result;
87223
87224   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87225   jresult = (int)result;
87226   return jresult;
87227 }
87228
87229
87230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87231   int jresult ;
87232   int result;
87233
87234   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87235   jresult = (int)result;
87236   return jresult;
87237 }
87238
87239
87240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87241   int jresult ;
87242   int result;
87243
87244   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87245   jresult = (int)result;
87246   return jresult;
87247 }
87248
87249
87250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87251   int jresult ;
87252   int result;
87253
87254   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87255   jresult = (int)result;
87256   return jresult;
87257 }
87258
87259
87260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87261   int jresult ;
87262   int result;
87263
87264   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87265   jresult = (int)result;
87266   return jresult;
87267 }
87268
87269
87270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87271   int jresult ;
87272   int result;
87273
87274   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87275   jresult = (int)result;
87276   return jresult;
87277 }
87278
87279
87280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87281   int jresult ;
87282   int result;
87283
87284   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87285   jresult = (int)result;
87286   return jresult;
87287 }
87288
87289
87290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87291   int jresult ;
87292   int result;
87293
87294   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87295   jresult = (int)result;
87296   return jresult;
87297 }
87298
87299
87300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87301   int jresult ;
87302   int result;
87303
87304   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87305   jresult = (int)result;
87306   return jresult;
87307 }
87308
87309
87310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87311   void * jresult ;
87312   Dali::Toolkit::Slider::Property *result = 0 ;
87313
87314   {
87315     try {
87316       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87317     } catch (std::out_of_range& e) {
87318       {
87319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87320       };
87321     } catch (std::exception& e) {
87322       {
87323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87324       };
87325     } catch (Dali::DaliException e) {
87326       {
87327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87328       };
87329     } catch (...) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87332       };
87333     }
87334   }
87335
87336   jresult = (void *)result;
87337   return jresult;
87338 }
87339
87340
87341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87342   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87343
87344   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87345   {
87346     try {
87347       delete arg1;
87348     } catch (std::out_of_range& e) {
87349       {
87350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87351       };
87352     } catch (std::exception& e) {
87353       {
87354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87355       };
87356     } catch (Dali::DaliException e) {
87357       {
87358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87359       };
87360     } catch (...) {
87361       {
87362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87363       };
87364     }
87365   }
87366
87367 }
87368
87369
87370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87371   void * jresult ;
87372   Dali::Toolkit::Slider result;
87373
87374   {
87375     try {
87376       result = Dali::Toolkit::Slider::New();
87377     } catch (std::out_of_range& e) {
87378       {
87379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87380       };
87381     } catch (std::exception& e) {
87382       {
87383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87384       };
87385     } catch (Dali::DaliException e) {
87386       {
87387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87388       };
87389     } catch (...) {
87390       {
87391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87392       };
87393     }
87394   }
87395
87396   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87397   return jresult;
87398 }
87399
87400
87401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87402   void * jresult ;
87403   Dali::Toolkit::Slider *result = 0 ;
87404
87405   {
87406     try {
87407       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87408     } catch (std::out_of_range& e) {
87409       {
87410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87411       };
87412     } catch (std::exception& e) {
87413       {
87414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87415       };
87416     } catch (Dali::DaliException e) {
87417       {
87418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87419       };
87420     } catch (...) {
87421       {
87422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87423       };
87424     }
87425   }
87426
87427   jresult = (void *)result;
87428   return jresult;
87429 }
87430
87431
87432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87433   void * jresult ;
87434   Dali::Toolkit::Slider *arg1 = 0 ;
87435   Dali::Toolkit::Slider *result = 0 ;
87436
87437   arg1 = (Dali::Toolkit::Slider *)jarg1;
87438   if (!arg1) {
87439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87440     return 0;
87441   }
87442   {
87443     try {
87444       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87445     } catch (std::out_of_range& e) {
87446       {
87447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87448       };
87449     } catch (std::exception& e) {
87450       {
87451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87452       };
87453     } catch (Dali::DaliException e) {
87454       {
87455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87456       };
87457     } catch (...) {
87458       {
87459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87460       };
87461     }
87462   }
87463
87464   jresult = (void *)result;
87465   return jresult;
87466 }
87467
87468
87469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87470   void * jresult ;
87471   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87472   Dali::Toolkit::Slider *arg2 = 0 ;
87473   Dali::Toolkit::Slider *result = 0 ;
87474
87475   arg1 = (Dali::Toolkit::Slider *)jarg1;
87476   arg2 = (Dali::Toolkit::Slider *)jarg2;
87477   if (!arg2) {
87478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87479     return 0;
87480   }
87481   {
87482     try {
87483       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87484     } catch (std::out_of_range& e) {
87485       {
87486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87487       };
87488     } catch (std::exception& e) {
87489       {
87490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87491       };
87492     } catch (Dali::DaliException e) {
87493       {
87494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87495       };
87496     } catch (...) {
87497       {
87498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87499       };
87500     }
87501   }
87502
87503   jresult = (void *)result;
87504   return jresult;
87505 }
87506
87507
87508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87509   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87510
87511   arg1 = (Dali::Toolkit::Slider *)jarg1;
87512   {
87513     try {
87514       delete arg1;
87515     } catch (std::out_of_range& e) {
87516       {
87517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87518       };
87519     } catch (std::exception& e) {
87520       {
87521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87522       };
87523     } catch (Dali::DaliException e) {
87524       {
87525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87526       };
87527     } catch (...) {
87528       {
87529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87530       };
87531     }
87532   }
87533
87534 }
87535
87536
87537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87538   void * jresult ;
87539   Dali::BaseHandle arg1 ;
87540   Dali::BaseHandle *argp1 ;
87541   Dali::Toolkit::Slider result;
87542
87543   argp1 = (Dali::BaseHandle *)jarg1;
87544   if (!argp1) {
87545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87546     return 0;
87547   }
87548   arg1 = *argp1;
87549   {
87550     try {
87551       result = Dali::Toolkit::Slider::DownCast(arg1);
87552     } catch (std::out_of_range& e) {
87553       {
87554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87555       };
87556     } catch (std::exception& e) {
87557       {
87558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87559       };
87560     } catch (Dali::DaliException e) {
87561       {
87562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87563       };
87564     } catch (...) {
87565       {
87566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87567       };
87568     }
87569   }
87570
87571   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87572   return jresult;
87573 }
87574
87575
87576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87577   void * jresult ;
87578   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87579   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87580
87581   arg1 = (Dali::Toolkit::Slider *)jarg1;
87582   {
87583     try {
87584       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87585     } catch (std::out_of_range& e) {
87586       {
87587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87588       };
87589     } catch (std::exception& e) {
87590       {
87591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87592       };
87593     } catch (Dali::DaliException e) {
87594       {
87595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87596       };
87597     } catch (...) {
87598       {
87599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87600       };
87601     }
87602   }
87603
87604   jresult = (void *)result;
87605   return jresult;
87606 }
87607
87608
87609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87610   void * jresult ;
87611   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87612   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87613
87614   arg1 = (Dali::Toolkit::Slider *)jarg1;
87615   {
87616     try {
87617       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87618     } catch (std::out_of_range& e) {
87619       {
87620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87621       };
87622     } catch (std::exception& e) {
87623       {
87624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87625       };
87626     } catch (Dali::DaliException e) {
87627       {
87628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87629       };
87630     } catch (...) {
87631       {
87632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87633       };
87634     }
87635   }
87636
87637   jresult = (void *)result;
87638   return jresult;
87639 }
87640
87641
87642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87643   void * jresult ;
87644   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87645   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87646
87647   arg1 = (Dali::Toolkit::Slider *)jarg1;
87648   {
87649     try {
87650       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87651     } catch (std::out_of_range& e) {
87652       {
87653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87654       };
87655     } catch (std::exception& e) {
87656       {
87657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87658       };
87659     } catch (Dali::DaliException e) {
87660       {
87661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87662       };
87663     } catch (...) {
87664       {
87665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87666       };
87667     }
87668   }
87669
87670   jresult = (void *)result;
87671   return jresult;
87672 }
87673
87674
87675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87676   int jresult ;
87677   int result;
87678
87679   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87680   jresult = (int)result;
87681   return jresult;
87682 }
87683
87684
87685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87686   int jresult ;
87687   int result;
87688
87689   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87690   jresult = (int)result;
87691   return jresult;
87692 }
87693
87694
87695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87696   int jresult ;
87697   int result;
87698
87699   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87700   jresult = (int)result;
87701   return jresult;
87702 }
87703
87704
87705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87706   int jresult ;
87707   int result;
87708
87709   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87710   jresult = (int)result;
87711   return jresult;
87712 }
87713
87714
87715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87716   int result;
87717
87718   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87719
87720   return result;
87721 }
87722
87723
87724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87725   void * jresult ;
87726   Dali::Toolkit::VideoView::Property *result = 0 ;
87727
87728   {
87729     try {
87730       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87731     } catch (std::out_of_range& e) {
87732       {
87733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87734       };
87735     } catch (std::exception& e) {
87736       {
87737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87738       };
87739     } catch (Dali::DaliException e) {
87740       {
87741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87742       };
87743     } catch (...) {
87744       {
87745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87746       };
87747     }
87748   }
87749
87750   jresult = (void *)result;
87751   return jresult;
87752 }
87753
87754
87755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87756   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87757
87758   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87759   {
87760     try {
87761       delete arg1;
87762     } catch (std::out_of_range& e) {
87763       {
87764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87765       };
87766     } catch (std::exception& e) {
87767       {
87768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87769       };
87770     } catch (Dali::DaliException e) {
87771       {
87772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87773       };
87774     } catch (...) {
87775       {
87776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87777       };
87778     }
87779   }
87780
87781 }
87782
87783
87784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87785   void * jresult ;
87786   Dali::Toolkit::VideoView result;
87787
87788   {
87789     try {
87790       result = Dali::Toolkit::VideoView::New();
87791     } catch (std::out_of_range& e) {
87792       {
87793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87794       };
87795     } catch (std::exception& e) {
87796       {
87797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87798       };
87799     } catch (Dali::DaliException e) {
87800       {
87801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87802       };
87803     } catch (...) {
87804       {
87805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87806       };
87807     }
87808   }
87809
87810   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87811   return jresult;
87812 }
87813
87814
87815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87816   void * jresult ;
87817   std::string *arg1 = 0 ;
87818   Dali::Toolkit::VideoView result;
87819
87820   if (!jarg1) {
87821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87822     return 0;
87823   }
87824   std::string arg1_str(jarg1);
87825   arg1 = &arg1_str;
87826   {
87827     try {
87828       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
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 = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87849
87850   //argout typemap for const std::string&
87851
87852   return jresult;
87853 }
87854
87855
87856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87857   void * jresult ;
87858   Dali::Toolkit::VideoView *result = 0 ;
87859
87860   {
87861     try {
87862       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87863     } catch (std::out_of_range& e) {
87864       {
87865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87866       };
87867     } catch (std::exception& e) {
87868       {
87869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87870       };
87871     } catch (Dali::DaliException e) {
87872       {
87873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87874       };
87875     } catch (...) {
87876       {
87877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87878       };
87879     }
87880   }
87881
87882   jresult = (void *)result;
87883   return jresult;
87884 }
87885
87886
87887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87888   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87889
87890   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87891   {
87892     try {
87893       delete arg1;
87894     } catch (std::out_of_range& e) {
87895       {
87896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87897       };
87898     } catch (std::exception& e) {
87899       {
87900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87901       };
87902     } catch (Dali::DaliException e) {
87903       {
87904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87905       };
87906     } catch (...) {
87907       {
87908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87909       };
87910     }
87911   }
87912
87913 }
87914
87915
87916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87917   void * jresult ;
87918   Dali::Toolkit::VideoView *arg1 = 0 ;
87919   Dali::Toolkit::VideoView *result = 0 ;
87920
87921   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87922   if (!arg1) {
87923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87924     return 0;
87925   }
87926   {
87927     try {
87928       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87929     } catch (std::out_of_range& e) {
87930       {
87931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87932       };
87933     } catch (std::exception& e) {
87934       {
87935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87936       };
87937     } catch (Dali::DaliException e) {
87938       {
87939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87940       };
87941     } catch (...) {
87942       {
87943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87944       };
87945     }
87946   }
87947
87948   jresult = (void *)result;
87949   return jresult;
87950 }
87951
87952
87953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87954   void * jresult ;
87955   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87956   Dali::Toolkit::VideoView *arg2 = 0 ;
87957   Dali::Toolkit::VideoView *result = 0 ;
87958
87959   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87960   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87961   if (!arg2) {
87962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87963     return 0;
87964   }
87965   {
87966     try {
87967       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87968     } catch (std::out_of_range& e) {
87969       {
87970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87971       };
87972     } catch (std::exception& e) {
87973       {
87974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87975       };
87976     } catch (Dali::DaliException e) {
87977       {
87978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87979       };
87980     } catch (...) {
87981       {
87982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87983       };
87984     }
87985   }
87986
87987   jresult = (void *)result;
87988   return jresult;
87989 }
87990
87991
87992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87993   void * jresult ;
87994   Dali::BaseHandle arg1 ;
87995   Dali::BaseHandle *argp1 ;
87996   Dali::Toolkit::VideoView result;
87997
87998   argp1 = (Dali::BaseHandle *)jarg1;
87999   if (!argp1) {
88000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88001     return 0;
88002   }
88003   arg1 = *argp1;
88004   {
88005     try {
88006       result = Dali::Toolkit::VideoView::DownCast(arg1);
88007     } catch (std::out_of_range& e) {
88008       {
88009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88010       };
88011     } catch (std::exception& e) {
88012       {
88013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88014       };
88015     } catch (Dali::DaliException e) {
88016       {
88017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88018       };
88019     } catch (...) {
88020       {
88021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88022       };
88023     }
88024   }
88025
88026   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
88027   return jresult;
88028 }
88029
88030
88031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
88032   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88033
88034   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88035   {
88036     try {
88037       (arg1)->Play();
88038     } catch (std::out_of_range& e) {
88039       {
88040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88041       };
88042     } catch (std::exception& e) {
88043       {
88044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88045       };
88046     } catch (Dali::DaliException e) {
88047       {
88048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88049       };
88050     } catch (...) {
88051       {
88052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88053       };
88054     }
88055   }
88056
88057 }
88058
88059
88060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
88061   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88062
88063   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88064   {
88065     try {
88066       (arg1)->Pause();
88067     } catch (std::out_of_range& e) {
88068       {
88069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88070       };
88071     } catch (std::exception& e) {
88072       {
88073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88074       };
88075     } catch (Dali::DaliException e) {
88076       {
88077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88078       };
88079     } catch (...) {
88080       {
88081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88082       };
88083     }
88084   }
88085
88086 }
88087
88088
88089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88090   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88091
88092   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88093   {
88094     try {
88095       (arg1)->Stop();
88096     } catch (std::out_of_range& e) {
88097       {
88098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88099       };
88100     } catch (std::exception& e) {
88101       {
88102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88103       };
88104     } catch (Dali::DaliException e) {
88105       {
88106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88107       };
88108     } catch (...) {
88109       {
88110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88111       };
88112     }
88113   }
88114
88115 }
88116
88117
88118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88119   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88120   int arg2 ;
88121
88122   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88123   arg2 = (int)jarg2;
88124   {
88125     try {
88126       (arg1)->Forward(arg2);
88127     } catch (std::out_of_range& e) {
88128       {
88129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88130       };
88131     } catch (std::exception& e) {
88132       {
88133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88134       };
88135     } catch (Dali::DaliException e) {
88136       {
88137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88138       };
88139     } catch (...) {
88140       {
88141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88142       };
88143     }
88144   }
88145
88146 }
88147
88148
88149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88150   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88151   int arg2 ;
88152
88153   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88154   arg2 = (int)jarg2;
88155   {
88156     try {
88157       (arg1)->Backward(arg2);
88158     } catch (std::out_of_range& e) {
88159       {
88160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88161       };
88162     } catch (std::exception& e) {
88163       {
88164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88165       };
88166     } catch (Dali::DaliException e) {
88167       {
88168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88169       };
88170     } catch (...) {
88171       {
88172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88173       };
88174     }
88175   }
88176
88177 }
88178
88179
88180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88181   void * jresult ;
88182   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88183   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88184
88185   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88186   {
88187     try {
88188       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88189     } catch (std::out_of_range& e) {
88190       {
88191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88192       };
88193     } catch (std::exception& e) {
88194       {
88195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88196       };
88197     } catch (Dali::DaliException e) {
88198       {
88199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88200       };
88201     } catch (...) {
88202       {
88203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88204       };
88205     }
88206   }
88207
88208   jresult = (void *)result;
88209   return jresult;
88210 }
88211
88212
88213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88214   int jresult ;
88215   int result;
88216
88217   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88218   jresult = (int)result;
88219   return jresult;
88220 }
88221
88222
88223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88224   int jresult ;
88225   int result;
88226
88227   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88228   jresult = (int)result;
88229   return jresult;
88230 }
88231
88232
88233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88234   int jresult ;
88235   int result;
88236
88237   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88238   jresult = (int)result;
88239   return jresult;
88240 }
88241
88242
88243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88244   int jresult ;
88245   int result;
88246
88247   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88248   jresult = (int)result;
88249   return jresult;
88250 }
88251
88252
88253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88254   int jresult ;
88255   int result;
88256
88257   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88258   jresult = (int)result;
88259   return jresult;
88260 }
88261
88262
88263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88264   int jresult ;
88265   int result;
88266
88267   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88268   jresult = (int)result;
88269   return jresult;
88270 }
88271
88272
88273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88274   int jresult ;
88275   int result;
88276
88277   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88278   jresult = (int)result;
88279   return jresult;
88280 }
88281
88282
88283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88284   int jresult ;
88285   int result;
88286
88287   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88288   jresult = (int)result;
88289   return jresult;
88290 }
88291
88292
88293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88294   int jresult ;
88295   int result;
88296
88297   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88298   jresult = (int)result;
88299   return jresult;
88300 }
88301
88302
88303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88304   int jresult ;
88305   int result;
88306
88307   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88308   jresult = (int)result;
88309   return jresult;
88310 }
88311
88312
88313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88314   int jresult ;
88315   int result;
88316
88317   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88318   jresult = (int)result;
88319   return jresult;
88320 }
88321
88322
88323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88324   int jresult ;
88325   int result;
88326
88327   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88328   jresult = (int)result;
88329   return jresult;
88330 }
88331
88332
88333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88334   int jresult ;
88335   int result;
88336
88337   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88338   jresult = (int)result;
88339   return jresult;
88340 }
88341
88342
88343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88344   int jresult ;
88345   int result;
88346
88347   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88348   jresult = (int)result;
88349   return jresult;
88350 }
88351
88352
88353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88354   int jresult ;
88355   int result;
88356
88357   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88358   jresult = (int)result;
88359   return jresult;
88360 }
88361
88362
88363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88364   int jresult ;
88365   int result;
88366
88367   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88368   jresult = (int)result;
88369   return jresult;
88370 }
88371
88372
88373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88374   int jresult ;
88375   int result;
88376
88377   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88378   jresult = (int)result;
88379   return jresult;
88380 }
88381
88382
88383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88384   int jresult ;
88385   int result;
88386
88387   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88388   jresult = (int)result;
88389   return jresult;
88390 }
88391
88392
88393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88394   int jresult ;
88395   int result;
88396
88397   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88398   jresult = (int)result;
88399   return jresult;
88400 }
88401
88402
88403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88404   int jresult ;
88405   int result;
88406
88407   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88408   jresult = (int)result;
88409   return jresult;
88410 }
88411
88412
88413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88414   int jresult ;
88415   int result;
88416
88417   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88418   jresult = (int)result;
88419   return jresult;
88420 }
88421
88422
88423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88424   void * jresult ;
88425   Dali::Toolkit::Popup::Property *result = 0 ;
88426
88427   {
88428     try {
88429       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88430     } catch (std::out_of_range& e) {
88431       {
88432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88433       };
88434     } catch (std::exception& e) {
88435       {
88436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88437       };
88438     } catch (Dali::DaliException e) {
88439       {
88440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88441       };
88442     } catch (...) {
88443       {
88444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88445       };
88446     }
88447   }
88448
88449   jresult = (void *)result;
88450   return jresult;
88451 }
88452
88453
88454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88455   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88456
88457   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88458   {
88459     try {
88460       delete arg1;
88461     } catch (std::out_of_range& e) {
88462       {
88463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88464       };
88465     } catch (std::exception& e) {
88466       {
88467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88468       };
88469     } catch (Dali::DaliException e) {
88470       {
88471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88472       };
88473     } catch (...) {
88474       {
88475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88476       };
88477     }
88478   }
88479
88480 }
88481
88482
88483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88484   void * jresult ;
88485   Dali::Toolkit::Popup *result = 0 ;
88486
88487   {
88488     try {
88489       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88490     } catch (std::out_of_range& e) {
88491       {
88492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88493       };
88494     } catch (std::exception& e) {
88495       {
88496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88497       };
88498     } catch (Dali::DaliException e) {
88499       {
88500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88501       };
88502     } catch (...) {
88503       {
88504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88505       };
88506     }
88507   }
88508
88509   jresult = (void *)result;
88510   return jresult;
88511 }
88512
88513
88514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88515   void * jresult ;
88516   Dali::Toolkit::Popup result;
88517
88518   {
88519     try {
88520       result = Dali::Toolkit::Popup::New();
88521     } catch (std::out_of_range& e) {
88522       {
88523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88524       };
88525     } catch (std::exception& e) {
88526       {
88527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88528       };
88529     } catch (Dali::DaliException e) {
88530       {
88531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88532       };
88533     } catch (...) {
88534       {
88535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88536       };
88537     }
88538   }
88539
88540   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88541   return jresult;
88542 }
88543
88544
88545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88546   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88547
88548   arg1 = (Dali::Toolkit::Popup *)jarg1;
88549   {
88550     try {
88551       delete arg1;
88552     } catch (std::out_of_range& e) {
88553       {
88554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88555       };
88556     } catch (std::exception& e) {
88557       {
88558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88559       };
88560     } catch (Dali::DaliException e) {
88561       {
88562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88563       };
88564     } catch (...) {
88565       {
88566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88567       };
88568     }
88569   }
88570
88571 }
88572
88573
88574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88575   void * jresult ;
88576   Dali::Toolkit::Popup *arg1 = 0 ;
88577   Dali::Toolkit::Popup *result = 0 ;
88578
88579   arg1 = (Dali::Toolkit::Popup *)jarg1;
88580   if (!arg1) {
88581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88582     return 0;
88583   }
88584   {
88585     try {
88586       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88587     } catch (std::out_of_range& e) {
88588       {
88589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88590       };
88591     } catch (std::exception& e) {
88592       {
88593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88594       };
88595     } catch (Dali::DaliException e) {
88596       {
88597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88598       };
88599     } catch (...) {
88600       {
88601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88602       };
88603     }
88604   }
88605
88606   jresult = (void *)result;
88607   return jresult;
88608 }
88609
88610
88611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88612   void * jresult ;
88613   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88614   Dali::Toolkit::Popup *arg2 = 0 ;
88615   Dali::Toolkit::Popup *result = 0 ;
88616
88617   arg1 = (Dali::Toolkit::Popup *)jarg1;
88618   arg2 = (Dali::Toolkit::Popup *)jarg2;
88619   if (!arg2) {
88620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88621     return 0;
88622   }
88623   {
88624     try {
88625       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88626     } catch (std::out_of_range& e) {
88627       {
88628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88629       };
88630     } catch (std::exception& e) {
88631       {
88632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88633       };
88634     } catch (Dali::DaliException e) {
88635       {
88636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88637       };
88638     } catch (...) {
88639       {
88640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88641       };
88642     }
88643   }
88644
88645   jresult = (void *)result;
88646   return jresult;
88647 }
88648
88649
88650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88651   void * jresult ;
88652   Dali::BaseHandle arg1 ;
88653   Dali::BaseHandle *argp1 ;
88654   Dali::Toolkit::Popup result;
88655
88656   argp1 = (Dali::BaseHandle *)jarg1;
88657   if (!argp1) {
88658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88659     return 0;
88660   }
88661   arg1 = *argp1;
88662   {
88663     try {
88664       result = Dali::Toolkit::Popup::DownCast(arg1);
88665     } catch (std::out_of_range& e) {
88666       {
88667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88668       };
88669     } catch (std::exception& e) {
88670       {
88671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88672       };
88673     } catch (Dali::DaliException e) {
88674       {
88675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88676       };
88677     } catch (...) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88680       };
88681     }
88682   }
88683
88684   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88685   return jresult;
88686 }
88687
88688
88689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88690   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88691   Dali::Actor arg2 ;
88692   Dali::Actor *argp2 ;
88693
88694   arg1 = (Dali::Toolkit::Popup *)jarg1;
88695   argp2 = (Dali::Actor *)jarg2;
88696   if (!argp2) {
88697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88698     return ;
88699   }
88700   arg2 = *argp2;
88701   {
88702     try {
88703       (arg1)->SetTitle(arg2);
88704     } catch (std::out_of_range& e) {
88705       {
88706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88707       };
88708     } catch (std::exception& e) {
88709       {
88710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88711       };
88712     } catch (Dali::DaliException e) {
88713       {
88714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88715       };
88716     } catch (...) {
88717       {
88718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88719       };
88720     }
88721   }
88722
88723 }
88724
88725
88726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88727   void * jresult ;
88728   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88729   Dali::Actor result;
88730
88731   arg1 = (Dali::Toolkit::Popup *)jarg1;
88732   {
88733     try {
88734       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88735     } catch (std::out_of_range& e) {
88736       {
88737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88738       };
88739     } catch (std::exception& e) {
88740       {
88741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88742       };
88743     } catch (Dali::DaliException e) {
88744       {
88745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88746       };
88747     } catch (...) {
88748       {
88749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88750       };
88751     }
88752   }
88753
88754   jresult = new Dali::Actor((const Dali::Actor &)result);
88755   return jresult;
88756 }
88757
88758
88759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88760   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88761   Dali::Actor arg2 ;
88762   Dali::Actor *argp2 ;
88763
88764   arg1 = (Dali::Toolkit::Popup *)jarg1;
88765   argp2 = (Dali::Actor *)jarg2;
88766   if (!argp2) {
88767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88768     return ;
88769   }
88770   arg2 = *argp2;
88771   {
88772     try {
88773       (arg1)->SetContent(arg2);
88774     } catch (std::out_of_range& e) {
88775       {
88776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88777       };
88778     } catch (std::exception& e) {
88779       {
88780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88781       };
88782     } catch (Dali::DaliException e) {
88783       {
88784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88785       };
88786     } catch (...) {
88787       {
88788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88789       };
88790     }
88791   }
88792
88793 }
88794
88795
88796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88797   void * jresult ;
88798   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88799   Dali::Actor result;
88800
88801   arg1 = (Dali::Toolkit::Popup *)jarg1;
88802   {
88803     try {
88804       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88805     } catch (std::out_of_range& e) {
88806       {
88807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88808       };
88809     } catch (std::exception& e) {
88810       {
88811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88812       };
88813     } catch (Dali::DaliException e) {
88814       {
88815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88816       };
88817     } catch (...) {
88818       {
88819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88820       };
88821     }
88822   }
88823
88824   jresult = new Dali::Actor((const Dali::Actor &)result);
88825   return jresult;
88826 }
88827
88828
88829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88830   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88831   Dali::Actor arg2 ;
88832   Dali::Actor *argp2 ;
88833
88834   arg1 = (Dali::Toolkit::Popup *)jarg1;
88835   argp2 = (Dali::Actor *)jarg2;
88836   if (!argp2) {
88837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88838     return ;
88839   }
88840   arg2 = *argp2;
88841   {
88842     try {
88843       (arg1)->SetFooter(arg2);
88844     } catch (std::out_of_range& e) {
88845       {
88846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88847       };
88848     } catch (std::exception& e) {
88849       {
88850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88851       };
88852     } catch (Dali::DaliException e) {
88853       {
88854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88855       };
88856     } catch (...) {
88857       {
88858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88859       };
88860     }
88861   }
88862
88863 }
88864
88865
88866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88867   void * jresult ;
88868   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88869   Dali::Actor result;
88870
88871   arg1 = (Dali::Toolkit::Popup *)jarg1;
88872   {
88873     try {
88874       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88875     } catch (std::out_of_range& e) {
88876       {
88877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88878       };
88879     } catch (std::exception& e) {
88880       {
88881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88882       };
88883     } catch (Dali::DaliException e) {
88884       {
88885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88886       };
88887     } catch (...) {
88888       {
88889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88890       };
88891     }
88892   }
88893
88894   jresult = new Dali::Actor((const Dali::Actor &)result);
88895   return jresult;
88896 }
88897
88898
88899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88900   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88901   Dali::Toolkit::Popup::DisplayState arg2 ;
88902
88903   arg1 = (Dali::Toolkit::Popup *)jarg1;
88904   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88905   {
88906     try {
88907       (arg1)->SetDisplayState(arg2);
88908     } catch (std::out_of_range& e) {
88909       {
88910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88911       };
88912     } catch (std::exception& e) {
88913       {
88914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88915       };
88916     } catch (Dali::DaliException e) {
88917       {
88918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88919       };
88920     } catch (...) {
88921       {
88922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88923       };
88924     }
88925   }
88926
88927 }
88928
88929
88930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88931   int jresult ;
88932   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88933   Dali::Toolkit::Popup::DisplayState result;
88934
88935   arg1 = (Dali::Toolkit::Popup *)jarg1;
88936   {
88937     try {
88938       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88939     } catch (std::out_of_range& e) {
88940       {
88941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88942       };
88943     } catch (std::exception& e) {
88944       {
88945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88946       };
88947     } catch (Dali::DaliException e) {
88948       {
88949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88950       };
88951     } catch (...) {
88952       {
88953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88954       };
88955     }
88956   }
88957
88958   jresult = (int)result;
88959   return jresult;
88960 }
88961
88962
88963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88964   void * jresult ;
88965   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88966   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88967
88968   arg1 = (Dali::Toolkit::Popup *)jarg1;
88969   {
88970     try {
88971       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88972     } catch (std::out_of_range& e) {
88973       {
88974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88975       };
88976     } catch (std::exception& e) {
88977       {
88978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88979       };
88980     } catch (Dali::DaliException e) {
88981       {
88982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88983       };
88984     } catch (...) {
88985       {
88986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88987       };
88988     }
88989   }
88990
88991   jresult = (void *)result;
88992   return jresult;
88993 }
88994
88995
88996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88997   void * jresult ;
88998   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88999   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89000
89001   arg1 = (Dali::Toolkit::Popup *)jarg1;
89002   {
89003     try {
89004       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
89005     } catch (std::out_of_range& e) {
89006       {
89007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89008       };
89009     } catch (std::exception& e) {
89010       {
89011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89012       };
89013     } catch (Dali::DaliException e) {
89014       {
89015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89016       };
89017     } catch (...) {
89018       {
89019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89020       };
89021     }
89022   }
89023
89024   jresult = (void *)result;
89025   return jresult;
89026 }
89027
89028
89029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
89030   void * jresult ;
89031   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89032   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89033
89034   arg1 = (Dali::Toolkit::Popup *)jarg1;
89035   {
89036     try {
89037       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
89038     } catch (std::out_of_range& e) {
89039       {
89040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89041       };
89042     } catch (std::exception& e) {
89043       {
89044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89045       };
89046     } catch (Dali::DaliException e) {
89047       {
89048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89049       };
89050     } catch (...) {
89051       {
89052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89053       };
89054     }
89055   }
89056
89057   jresult = (void *)result;
89058   return jresult;
89059 }
89060
89061
89062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
89063   void * jresult ;
89064   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89065   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89066
89067   arg1 = (Dali::Toolkit::Popup *)jarg1;
89068   {
89069     try {
89070       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
89071     } catch (std::out_of_range& e) {
89072       {
89073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89074       };
89075     } catch (std::exception& e) {
89076       {
89077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89078       };
89079     } catch (Dali::DaliException e) {
89080       {
89081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89082       };
89083     } catch (...) {
89084       {
89085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89086       };
89087     }
89088   }
89089
89090   jresult = (void *)result;
89091   return jresult;
89092 }
89093
89094
89095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89096   void * jresult ;
89097   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89098   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89099
89100   arg1 = (Dali::Toolkit::Popup *)jarg1;
89101   {
89102     try {
89103       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89104     } catch (std::out_of_range& e) {
89105       {
89106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89107       };
89108     } catch (std::exception& e) {
89109       {
89110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89111       };
89112     } catch (Dali::DaliException e) {
89113       {
89114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89115       };
89116     } catch (...) {
89117       {
89118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89119       };
89120     }
89121   }
89122
89123   jresult = (void *)result;
89124   return jresult;
89125 }
89126
89127
89128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89129   int jresult ;
89130   int result;
89131
89132   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89133   jresult = (int)result;
89134   return jresult;
89135 }
89136
89137
89138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89139   int jresult ;
89140   int result;
89141
89142   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89143   jresult = (int)result;
89144   return jresult;
89145 }
89146
89147
89148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89149   int jresult ;
89150   int result;
89151
89152   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89153   jresult = (int)result;
89154   return jresult;
89155 }
89156
89157
89158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89159   int jresult ;
89160   int result;
89161
89162   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89163   jresult = (int)result;
89164   return jresult;
89165 }
89166
89167
89168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89169   int jresult ;
89170   int result;
89171
89172   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89173   jresult = (int)result;
89174   return jresult;
89175 }
89176
89177
89178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89179   int jresult ;
89180   int result;
89181
89182   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89183   jresult = (int)result;
89184   return jresult;
89185 }
89186
89187
89188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89189   int jresult ;
89190   int result;
89191
89192   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89193   jresult = (int)result;
89194   return jresult;
89195 }
89196
89197
89198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89199   int jresult ;
89200   int result;
89201
89202   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89203   jresult = (int)result;
89204   return jresult;
89205 }
89206
89207
89208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89209   int jresult ;
89210   int result;
89211
89212   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89213   jresult = (int)result;
89214   return jresult;
89215 }
89216
89217
89218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89219   void * jresult ;
89220   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89221
89222   {
89223     try {
89224       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89225     } catch (std::out_of_range& e) {
89226       {
89227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89228       };
89229     } catch (std::exception& e) {
89230       {
89231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89232       };
89233     } catch (Dali::DaliException e) {
89234       {
89235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89236       };
89237     } catch (...) {
89238       {
89239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89240       };
89241     }
89242   }
89243
89244   jresult = (void *)result;
89245   return jresult;
89246 }
89247
89248
89249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89250   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89251
89252   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89253   {
89254     try {
89255       delete arg1;
89256     } catch (std::out_of_range& e) {
89257       {
89258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89259       };
89260     } catch (std::exception& e) {
89261       {
89262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89263       };
89264     } catch (Dali::DaliException e) {
89265       {
89266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89267       };
89268     } catch (...) {
89269       {
89270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89271       };
89272     }
89273   }
89274
89275 }
89276
89277
89278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89279   void * jresult ;
89280   Dali::Toolkit::ProgressBar result;
89281
89282   {
89283     try {
89284       result = Dali::Toolkit::ProgressBar::New();
89285     } catch (std::out_of_range& e) {
89286       {
89287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89288       };
89289     } catch (std::exception& e) {
89290       {
89291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89292       };
89293     } catch (Dali::DaliException e) {
89294       {
89295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89296       };
89297     } catch (...) {
89298       {
89299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89300       };
89301     }
89302   }
89303
89304   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89305   return jresult;
89306 }
89307
89308
89309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89310   void * jresult ;
89311   Dali::Toolkit::ProgressBar *result = 0 ;
89312
89313   {
89314     try {
89315       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89316     } catch (std::out_of_range& e) {
89317       {
89318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89319       };
89320     } catch (std::exception& e) {
89321       {
89322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89323       };
89324     } catch (Dali::DaliException e) {
89325       {
89326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89327       };
89328     } catch (...) {
89329       {
89330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89331       };
89332     }
89333   }
89334
89335   jresult = (void *)result;
89336   return jresult;
89337 }
89338
89339
89340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89341   void * jresult ;
89342   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89343   Dali::Toolkit::ProgressBar *result = 0 ;
89344
89345   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89346   if (!arg1) {
89347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89348     return 0;
89349   }
89350   {
89351     try {
89352       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89353     } catch (std::out_of_range& e) {
89354       {
89355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89356       };
89357     } catch (std::exception& e) {
89358       {
89359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89360       };
89361     } catch (Dali::DaliException e) {
89362       {
89363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89364       };
89365     } catch (...) {
89366       {
89367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89368       };
89369     }
89370   }
89371
89372   jresult = (void *)result;
89373   return jresult;
89374 }
89375
89376
89377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89378   void * jresult ;
89379   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89380   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89381   Dali::Toolkit::ProgressBar *result = 0 ;
89382
89383   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89384   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89385   if (!arg2) {
89386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89387     return 0;
89388   }
89389   {
89390     try {
89391       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89392     } catch (std::out_of_range& e) {
89393       {
89394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89395       };
89396     } catch (std::exception& e) {
89397       {
89398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89399       };
89400     } catch (Dali::DaliException e) {
89401       {
89402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89403       };
89404     } catch (...) {
89405       {
89406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89407       };
89408     }
89409   }
89410
89411   jresult = (void *)result;
89412   return jresult;
89413 }
89414
89415
89416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89417   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89418
89419   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89420   {
89421     try {
89422       delete arg1;
89423     } catch (std::out_of_range& e) {
89424       {
89425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89426       };
89427     } catch (std::exception& e) {
89428       {
89429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89430       };
89431     } catch (Dali::DaliException e) {
89432       {
89433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89434       };
89435     } catch (...) {
89436       {
89437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89438       };
89439     }
89440   }
89441
89442 }
89443
89444
89445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89446   void * jresult ;
89447   Dali::BaseHandle arg1 ;
89448   Dali::BaseHandle *argp1 ;
89449   Dali::Toolkit::ProgressBar result;
89450
89451   argp1 = (Dali::BaseHandle *)jarg1;
89452   if (!argp1) {
89453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89454     return 0;
89455   }
89456   arg1 = *argp1;
89457   {
89458     try {
89459       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89460     } catch (std::out_of_range& e) {
89461       {
89462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89463       };
89464     } catch (std::exception& e) {
89465       {
89466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89467       };
89468     } catch (Dali::DaliException e) {
89469       {
89470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89471       };
89472     } catch (...) {
89473       {
89474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89475       };
89476     }
89477   }
89478
89479   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89480   return jresult;
89481 }
89482
89483
89484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89485   void * jresult ;
89486   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89487   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89488
89489   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89490   {
89491     try {
89492       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89493     } catch (std::out_of_range& e) {
89494       {
89495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89496       };
89497     } catch (std::exception& e) {
89498       {
89499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89500       };
89501     } catch (Dali::DaliException e) {
89502       {
89503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89504       };
89505     } catch (...) {
89506       {
89507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89508       };
89509     }
89510   }
89511
89512   jresult = (void *)result;
89513   return jresult;
89514 }
89515
89516
89517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89518   void * jresult ;
89519   Dali::Toolkit::GaussianBlurView *result = 0 ;
89520
89521   {
89522     try {
89523       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89524     } catch (std::out_of_range& e) {
89525       {
89526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89527       };
89528     } catch (std::exception& e) {
89529       {
89530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89531       };
89532     } catch (Dali::DaliException e) {
89533       {
89534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89535       };
89536     } catch (...) {
89537       {
89538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89539       };
89540     }
89541   }
89542
89543   jresult = (void *)result;
89544   return jresult;
89545 }
89546
89547
89548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89549   void * jresult ;
89550   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89551   Dali::Toolkit::GaussianBlurView *result = 0 ;
89552
89553   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89554   if (!arg1) {
89555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89556     return 0;
89557   }
89558   {
89559     try {
89560       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89561     } catch (std::out_of_range& e) {
89562       {
89563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89564       };
89565     } catch (std::exception& e) {
89566       {
89567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89568       };
89569     } catch (Dali::DaliException e) {
89570       {
89571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89572       };
89573     } catch (...) {
89574       {
89575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89576       };
89577     }
89578   }
89579
89580   jresult = (void *)result;
89581   return jresult;
89582 }
89583
89584
89585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89586   void * jresult ;
89587   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89588   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89589   Dali::Toolkit::GaussianBlurView *result = 0 ;
89590
89591   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89592   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89593   if (!arg2) {
89594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89595     return 0;
89596   }
89597   {
89598     try {
89599       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89600     } catch (std::out_of_range& e) {
89601       {
89602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89603       };
89604     } catch (std::exception& e) {
89605       {
89606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89607       };
89608     } catch (Dali::DaliException e) {
89609       {
89610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89611       };
89612     } catch (...) {
89613       {
89614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89615       };
89616     }
89617   }
89618
89619   jresult = (void *)result;
89620   return jresult;
89621 }
89622
89623
89624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89625   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89626
89627   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89628   {
89629     try {
89630       delete arg1;
89631     } catch (std::out_of_range& e) {
89632       {
89633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89634       };
89635     } catch (std::exception& e) {
89636       {
89637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89638       };
89639     } catch (Dali::DaliException e) {
89640       {
89641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89642       };
89643     } catch (...) {
89644       {
89645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89646       };
89647     }
89648   }
89649
89650 }
89651
89652
89653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89654   void * jresult ;
89655   Dali::BaseHandle arg1 ;
89656   Dali::BaseHandle *argp1 ;
89657   Dali::Toolkit::GaussianBlurView result;
89658
89659   argp1 = (Dali::BaseHandle *)jarg1;
89660   if (!argp1) {
89661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89662     return 0;
89663   }
89664   arg1 = *argp1;
89665   {
89666     try {
89667       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89668     } catch (std::out_of_range& e) {
89669       {
89670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89671       };
89672     } catch (std::exception& e) {
89673       {
89674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89675       };
89676     } catch (Dali::DaliException e) {
89677       {
89678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89679       };
89680     } catch (...) {
89681       {
89682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89683       };
89684     }
89685   }
89686
89687   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89688   return jresult;
89689 }
89690
89691
89692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89693   void * jresult ;
89694   Dali::Toolkit::GaussianBlurView result;
89695
89696   {
89697     try {
89698       result = Dali::Toolkit::GaussianBlurView::New();
89699     } catch (std::out_of_range& e) {
89700       {
89701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89702       };
89703     } catch (std::exception& e) {
89704       {
89705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89706       };
89707     } catch (Dali::DaliException e) {
89708       {
89709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89710       };
89711     } catch (...) {
89712       {
89713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89714       };
89715     }
89716   }
89717
89718   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89719   return jresult;
89720 }
89721
89722
89723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89724   void * jresult ;
89725   unsigned int arg1 ;
89726   float arg2 ;
89727   Dali::Pixel::Format arg3 ;
89728   float arg4 ;
89729   float arg5 ;
89730   bool arg6 ;
89731   Dali::Toolkit::GaussianBlurView result;
89732
89733   arg1 = (unsigned int)jarg1;
89734   arg2 = (float)jarg2;
89735   arg3 = (Dali::Pixel::Format)jarg3;
89736   arg4 = (float)jarg4;
89737   arg5 = (float)jarg5;
89738   arg6 = jarg6 ? true : false;
89739   {
89740     try {
89741       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89742     } catch (std::out_of_range& e) {
89743       {
89744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89745       };
89746     } catch (std::exception& e) {
89747       {
89748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89749       };
89750     } catch (Dali::DaliException e) {
89751       {
89752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89753       };
89754     } catch (...) {
89755       {
89756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89757       };
89758     }
89759   }
89760
89761   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89762   return jresult;
89763 }
89764
89765
89766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89767   void * jresult ;
89768   unsigned int arg1 ;
89769   float arg2 ;
89770   Dali::Pixel::Format arg3 ;
89771   float arg4 ;
89772   float arg5 ;
89773   Dali::Toolkit::GaussianBlurView result;
89774
89775   arg1 = (unsigned int)jarg1;
89776   arg2 = (float)jarg2;
89777   arg3 = (Dali::Pixel::Format)jarg3;
89778   arg4 = (float)jarg4;
89779   arg5 = (float)jarg5;
89780   {
89781     try {
89782       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89783     } catch (std::out_of_range& e) {
89784       {
89785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89786       };
89787     } catch (std::exception& e) {
89788       {
89789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89790       };
89791     } catch (Dali::DaliException e) {
89792       {
89793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89794       };
89795     } catch (...) {
89796       {
89797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89798       };
89799     }
89800   }
89801
89802   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89803   return jresult;
89804 }
89805
89806
89807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89808   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89809   Dali::Actor arg2 ;
89810   Dali::Actor *argp2 ;
89811
89812   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89813   argp2 = (Dali::Actor *)jarg2;
89814   if (!argp2) {
89815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89816     return ;
89817   }
89818   arg2 = *argp2;
89819   {
89820     try {
89821       (arg1)->Add(arg2);
89822     } catch (std::out_of_range& e) {
89823       {
89824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89825       };
89826     } catch (std::exception& e) {
89827       {
89828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89829       };
89830     } catch (Dali::DaliException e) {
89831       {
89832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89833       };
89834     } catch (...) {
89835       {
89836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89837       };
89838     }
89839   }
89840
89841 }
89842
89843
89844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89845   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89846   Dali::Actor arg2 ;
89847   Dali::Actor *argp2 ;
89848
89849   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89850   argp2 = (Dali::Actor *)jarg2;
89851   if (!argp2) {
89852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89853     return ;
89854   }
89855   arg2 = *argp2;
89856   {
89857     try {
89858       (arg1)->Remove(arg2);
89859     } catch (std::out_of_range& e) {
89860       {
89861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89862       };
89863     } catch (std::exception& e) {
89864       {
89865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89866       };
89867     } catch (Dali::DaliException e) {
89868       {
89869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89870       };
89871     } catch (...) {
89872       {
89873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89874       };
89875     }
89876   }
89877
89878 }
89879
89880
89881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89882   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89883
89884   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89885   {
89886     try {
89887       (arg1)->Activate();
89888     } catch (std::out_of_range& e) {
89889       {
89890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89891       };
89892     } catch (std::exception& e) {
89893       {
89894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89895       };
89896     } catch (Dali::DaliException e) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89899       };
89900     } catch (...) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89903       };
89904     }
89905   }
89906
89907 }
89908
89909
89910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89911   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89912
89913   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89914   {
89915     try {
89916       (arg1)->ActivateOnce();
89917     } catch (std::out_of_range& e) {
89918       {
89919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89920       };
89921     } catch (std::exception& e) {
89922       {
89923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89924       };
89925     } catch (Dali::DaliException e) {
89926       {
89927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89928       };
89929     } catch (...) {
89930       {
89931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89932       };
89933     }
89934   }
89935
89936 }
89937
89938
89939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89940   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89941
89942   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89943   {
89944     try {
89945       (arg1)->Deactivate();
89946     } catch (std::out_of_range& e) {
89947       {
89948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89949       };
89950     } catch (std::exception& e) {
89951       {
89952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89953       };
89954     } catch (Dali::DaliException e) {
89955       {
89956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89957       };
89958     } catch (...) {
89959       {
89960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89961       };
89962     }
89963   }
89964
89965 }
89966
89967
89968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89969   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89970   Dali::Image arg2 ;
89971   Dali::FrameBufferImage arg3 ;
89972   Dali::Image *argp2 ;
89973   Dali::FrameBufferImage *argp3 ;
89974
89975   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89976   argp2 = (Dali::Image *)jarg2;
89977   if (!argp2) {
89978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89979     return ;
89980   }
89981   arg2 = *argp2;
89982   argp3 = (Dali::FrameBufferImage *)jarg3;
89983   if (!argp3) {
89984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89985     return ;
89986   }
89987   arg3 = *argp3;
89988   {
89989     try {
89990       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89991     } catch (std::out_of_range& e) {
89992       {
89993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89994       };
89995     } catch (std::exception& e) {
89996       {
89997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89998       };
89999     } catch (Dali::DaliException e) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90002       };
90003     } catch (...) {
90004       {
90005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90006       };
90007     }
90008   }
90009
90010 }
90011
90012
90013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
90014   int jresult ;
90015   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90016   Dali::Property::Index result;
90017
90018   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90019   {
90020     try {
90021       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
90022     } catch (std::out_of_range& e) {
90023       {
90024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90025       };
90026     } catch (std::exception& e) {
90027       {
90028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90029       };
90030     } catch (Dali::DaliException e) {
90031       {
90032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90033       };
90034     } catch (...) {
90035       {
90036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90037       };
90038     }
90039   }
90040
90041   jresult = result;
90042   return jresult;
90043 }
90044
90045
90046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
90047   void * jresult ;
90048   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90049   Dali::FrameBufferImage result;
90050
90051   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90052   {
90053     try {
90054       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
90055     } catch (std::out_of_range& e) {
90056       {
90057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90058       };
90059     } catch (std::exception& e) {
90060       {
90061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90062       };
90063     } catch (Dali::DaliException e) {
90064       {
90065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90066       };
90067     } catch (...) {
90068       {
90069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90070       };
90071     }
90072   }
90073
90074   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
90075   return jresult;
90076 }
90077
90078
90079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90080   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90081   Dali::Vector4 *arg2 = 0 ;
90082
90083   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90084   arg2 = (Dali::Vector4 *)jarg2;
90085   if (!arg2) {
90086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90087     return ;
90088   }
90089   {
90090     try {
90091       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90092     } catch (std::out_of_range& e) {
90093       {
90094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90095       };
90096     } catch (std::exception& e) {
90097       {
90098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90099       };
90100     } catch (Dali::DaliException e) {
90101       {
90102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90103       };
90104     } catch (...) {
90105       {
90106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90107       };
90108     }
90109   }
90110
90111 }
90112
90113
90114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90115   void * jresult ;
90116   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90117   Dali::Vector4 result;
90118
90119   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90120   {
90121     try {
90122       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90123     } catch (std::out_of_range& e) {
90124       {
90125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90126       };
90127     } catch (std::exception& e) {
90128       {
90129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90130       };
90131     } catch (Dali::DaliException e) {
90132       {
90133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90134       };
90135     } catch (...) {
90136       {
90137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90138       };
90139     }
90140   }
90141
90142   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90143   return jresult;
90144 }
90145
90146
90147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90148   void * jresult ;
90149   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90150   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90151
90152   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90153   {
90154     try {
90155       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90156     } catch (std::out_of_range& e) {
90157       {
90158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90159       };
90160     } catch (std::exception& e) {
90161       {
90162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90163       };
90164     } catch (Dali::DaliException e) {
90165       {
90166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90167       };
90168     } catch (...) {
90169       {
90170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90171       };
90172     }
90173   }
90174
90175   jresult = (void *)result;
90176   return jresult;
90177 }
90178
90179
90180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90181   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90182
90183   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90184   {
90185     try {
90186       delete arg1;
90187     } catch (std::out_of_range& e) {
90188       {
90189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90190       };
90191     } catch (std::exception& e) {
90192       {
90193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90194       };
90195     } catch (Dali::DaliException e) {
90196       {
90197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90198       };
90199     } catch (...) {
90200       {
90201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90202       };
90203     }
90204   }
90205
90206 }
90207
90208
90209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90210   unsigned int jresult ;
90211   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90212   unsigned int result;
90213
90214   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90215   {
90216     try {
90217       result = (unsigned int)(arg1)->GetNumberOfPages();
90218     } catch (std::out_of_range& e) {
90219       {
90220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90221       };
90222     } catch (std::exception& e) {
90223       {
90224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90225       };
90226     } catch (Dali::DaliException e) {
90227       {
90228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90229       };
90230     } catch (...) {
90231       {
90232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90233       };
90234     }
90235   }
90236
90237   jresult = result;
90238   return jresult;
90239 }
90240
90241
90242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90243   void * jresult ;
90244   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90245   unsigned int arg2 ;
90246   Dali::Texture result;
90247
90248   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90249   arg2 = (unsigned int)jarg2;
90250   {
90251     try {
90252       result = (arg1)->NewPage(arg2);
90253     } catch (std::out_of_range& e) {
90254       {
90255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90256       };
90257     } catch (std::exception& e) {
90258       {
90259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90260       };
90261     } catch (Dali::DaliException e) {
90262       {
90263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90264       };
90265     } catch (...) {
90266       {
90267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90268       };
90269     }
90270   }
90271
90272   jresult = new Dali::Texture((const Dali::Texture &)result);
90273   return jresult;
90274 }
90275
90276
90277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90278   int jresult ;
90279   int result;
90280
90281   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90282   jresult = (int)result;
90283   return jresult;
90284 }
90285
90286
90287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90288   int jresult ;
90289   int result;
90290
90291   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90292   jresult = (int)result;
90293   return jresult;
90294 }
90295
90296
90297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90298   int jresult ;
90299   int result;
90300
90301   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90302   jresult = (int)result;
90303   return jresult;
90304 }
90305
90306
90307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90308   void * jresult ;
90309   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90310
90311   {
90312     try {
90313       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90314     } catch (std::out_of_range& e) {
90315       {
90316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90317       };
90318     } catch (std::exception& e) {
90319       {
90320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90321       };
90322     } catch (Dali::DaliException e) {
90323       {
90324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90325       };
90326     } catch (...) {
90327       {
90328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90329       };
90330     }
90331   }
90332
90333   jresult = (void *)result;
90334   return jresult;
90335 }
90336
90337
90338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90339   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90340
90341   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90342   {
90343     try {
90344       delete arg1;
90345     } catch (std::out_of_range& e) {
90346       {
90347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90348       };
90349     } catch (std::exception& e) {
90350       {
90351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90352       };
90353     } catch (Dali::DaliException e) {
90354       {
90355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90356       };
90357     } catch (...) {
90358       {
90359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90360       };
90361     }
90362   }
90363
90364 }
90365
90366
90367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90368   void * jresult ;
90369   Dali::Toolkit::PageTurnView *result = 0 ;
90370
90371   {
90372     try {
90373       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90374     } catch (std::out_of_range& e) {
90375       {
90376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90377       };
90378     } catch (std::exception& e) {
90379       {
90380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90381       };
90382     } catch (Dali::DaliException e) {
90383       {
90384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90385       };
90386     } catch (...) {
90387       {
90388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90389       };
90390     }
90391   }
90392
90393   jresult = (void *)result;
90394   return jresult;
90395 }
90396
90397
90398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90399   void * jresult ;
90400   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90401   Dali::Toolkit::PageTurnView *result = 0 ;
90402
90403   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90404   if (!arg1) {
90405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90406     return 0;
90407   }
90408   {
90409     try {
90410       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90411     } catch (std::out_of_range& e) {
90412       {
90413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90414       };
90415     } catch (std::exception& e) {
90416       {
90417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90418       };
90419     } catch (Dali::DaliException e) {
90420       {
90421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90422       };
90423     } catch (...) {
90424       {
90425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90426       };
90427     }
90428   }
90429
90430   jresult = (void *)result;
90431   return jresult;
90432 }
90433
90434
90435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90436   void * jresult ;
90437   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90438   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90439   Dali::Toolkit::PageTurnView *result = 0 ;
90440
90441   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90442   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90443   if (!arg2) {
90444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90445     return 0;
90446   }
90447   {
90448     try {
90449       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90450     } catch (std::out_of_range& e) {
90451       {
90452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90453       };
90454     } catch (std::exception& e) {
90455       {
90456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90457       };
90458     } catch (Dali::DaliException e) {
90459       {
90460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90461       };
90462     } catch (...) {
90463       {
90464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90465       };
90466     }
90467   }
90468
90469   jresult = (void *)result;
90470   return jresult;
90471 }
90472
90473
90474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90475   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90476
90477   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90478   {
90479     try {
90480       delete arg1;
90481     } catch (std::out_of_range& e) {
90482       {
90483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90484       };
90485     } catch (std::exception& e) {
90486       {
90487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90488       };
90489     } catch (Dali::DaliException e) {
90490       {
90491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90492       };
90493     } catch (...) {
90494       {
90495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90496       };
90497     }
90498   }
90499
90500 }
90501
90502
90503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90504   void * jresult ;
90505   Dali::BaseHandle arg1 ;
90506   Dali::BaseHandle *argp1 ;
90507   Dali::Toolkit::PageTurnView result;
90508
90509   argp1 = (Dali::BaseHandle *)jarg1;
90510   if (!argp1) {
90511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90512     return 0;
90513   }
90514   arg1 = *argp1;
90515   {
90516     try {
90517       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90518     } catch (std::out_of_range& e) {
90519       {
90520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90521       };
90522     } catch (std::exception& e) {
90523       {
90524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90525       };
90526     } catch (Dali::DaliException e) {
90527       {
90528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90529       };
90530     } catch (...) {
90531       {
90532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90533       };
90534     }
90535   }
90536
90537   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90538   return jresult;
90539 }
90540
90541
90542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90543   void * jresult ;
90544   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90545   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90546
90547   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90548   {
90549     try {
90550       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90551     } catch (std::out_of_range& e) {
90552       {
90553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90554       };
90555     } catch (std::exception& e) {
90556       {
90557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90558       };
90559     } catch (Dali::DaliException e) {
90560       {
90561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90562       };
90563     } catch (...) {
90564       {
90565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90566       };
90567     }
90568   }
90569
90570   jresult = (void *)result;
90571   return jresult;
90572 }
90573
90574
90575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90576   void * jresult ;
90577   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90578   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90579
90580   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90581   {
90582     try {
90583       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90584     } catch (std::out_of_range& e) {
90585       {
90586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90587       };
90588     } catch (std::exception& e) {
90589       {
90590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90591       };
90592     } catch (Dali::DaliException e) {
90593       {
90594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90595       };
90596     } catch (...) {
90597       {
90598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90599       };
90600     }
90601   }
90602
90603   jresult = (void *)result;
90604   return jresult;
90605 }
90606
90607
90608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90609   void * jresult ;
90610   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90611   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90612
90613   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90614   {
90615     try {
90616       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90617     } catch (std::out_of_range& e) {
90618       {
90619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90620       };
90621     } catch (std::exception& e) {
90622       {
90623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90624       };
90625     } catch (Dali::DaliException e) {
90626       {
90627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90628       };
90629     } catch (...) {
90630       {
90631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90632       };
90633     }
90634   }
90635
90636   jresult = (void *)result;
90637   return jresult;
90638 }
90639
90640
90641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90642   void * jresult ;
90643   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90644   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90645
90646   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90647   {
90648     try {
90649       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90650     } catch (std::out_of_range& e) {
90651       {
90652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90653       };
90654     } catch (std::exception& e) {
90655       {
90656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90657       };
90658     } catch (Dali::DaliException e) {
90659       {
90660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90661       };
90662     } catch (...) {
90663       {
90664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90665       };
90666     }
90667   }
90668
90669   jresult = (void *)result;
90670   return jresult;
90671 }
90672
90673
90674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90675   void * jresult ;
90676   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90677
90678   {
90679     try {
90680       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90681     } catch (std::out_of_range& e) {
90682       {
90683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90684       };
90685     } catch (std::exception& e) {
90686       {
90687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90688       };
90689     } catch (Dali::DaliException e) {
90690       {
90691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90692       };
90693     } catch (...) {
90694       {
90695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90696       };
90697     }
90698   }
90699
90700   jresult = (void *)result;
90701   return jresult;
90702 }
90703
90704
90705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90706   void * jresult ;
90707   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90708   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90709
90710   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90711   if (!arg1) {
90712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90713     return 0;
90714   }
90715   {
90716     try {
90717       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90718     } catch (std::out_of_range& e) {
90719       {
90720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90721       };
90722     } catch (std::exception& e) {
90723       {
90724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90725       };
90726     } catch (Dali::DaliException e) {
90727       {
90728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90729       };
90730     } catch (...) {
90731       {
90732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90733       };
90734     }
90735   }
90736
90737   jresult = (void *)result;
90738   return jresult;
90739 }
90740
90741
90742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90743   void * jresult ;
90744   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90745   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90746   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90747
90748   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90749   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90750   if (!arg2) {
90751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90752     return 0;
90753   }
90754   {
90755     try {
90756       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90757     } catch (std::out_of_range& e) {
90758       {
90759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90760       };
90761     } catch (std::exception& e) {
90762       {
90763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90764       };
90765     } catch (Dali::DaliException e) {
90766       {
90767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90768       };
90769     } catch (...) {
90770       {
90771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90772       };
90773     }
90774   }
90775
90776   jresult = (void *)result;
90777   return jresult;
90778 }
90779
90780
90781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90782   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90783
90784   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90785   {
90786     try {
90787       delete arg1;
90788     } catch (std::out_of_range& e) {
90789       {
90790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90791       };
90792     } catch (std::exception& e) {
90793       {
90794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90795       };
90796     } catch (Dali::DaliException e) {
90797       {
90798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90799       };
90800     } catch (...) {
90801       {
90802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90803       };
90804     }
90805   }
90806
90807 }
90808
90809
90810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90811   void * jresult ;
90812   Dali::Toolkit::PageFactory *arg1 = 0 ;
90813   Dali::Vector2 *arg2 = 0 ;
90814   Dali::Toolkit::PageTurnLandscapeView result;
90815
90816   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90817   if (!arg1) {
90818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90819     return 0;
90820   }
90821   arg2 = (Dali::Vector2 *)jarg2;
90822   if (!arg2) {
90823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90824     return 0;
90825   }
90826   {
90827     try {
90828       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90829     } catch (std::out_of_range& e) {
90830       {
90831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90832       };
90833     } catch (std::exception& e) {
90834       {
90835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90836       };
90837     } catch (Dali::DaliException e) {
90838       {
90839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90840       };
90841     } catch (...) {
90842       {
90843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90844       };
90845     }
90846   }
90847
90848   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90849   return jresult;
90850 }
90851
90852
90853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90854   void * jresult ;
90855   Dali::BaseHandle arg1 ;
90856   Dali::BaseHandle *argp1 ;
90857   Dali::Toolkit::PageTurnLandscapeView result;
90858
90859   argp1 = (Dali::BaseHandle *)jarg1;
90860   if (!argp1) {
90861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90862     return 0;
90863   }
90864   arg1 = *argp1;
90865   {
90866     try {
90867       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90868     } catch (std::out_of_range& e) {
90869       {
90870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90871       };
90872     } catch (std::exception& e) {
90873       {
90874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90875       };
90876     } catch (Dali::DaliException e) {
90877       {
90878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90879       };
90880     } catch (...) {
90881       {
90882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90883       };
90884     }
90885   }
90886
90887   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90888   return jresult;
90889 }
90890
90891
90892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90893   void * jresult ;
90894   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90895
90896   {
90897     try {
90898       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90899     } catch (std::out_of_range& e) {
90900       {
90901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90902       };
90903     } catch (std::exception& e) {
90904       {
90905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90906       };
90907     } catch (Dali::DaliException e) {
90908       {
90909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90910       };
90911     } catch (...) {
90912       {
90913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90914       };
90915     }
90916   }
90917
90918   jresult = (void *)result;
90919   return jresult;
90920 }
90921
90922
90923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90924   void * jresult ;
90925   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90926   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90927
90928   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90929   if (!arg1) {
90930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90931     return 0;
90932   }
90933   {
90934     try {
90935       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90936     } catch (std::out_of_range& e) {
90937       {
90938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90939       };
90940     } catch (std::exception& e) {
90941       {
90942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90943       };
90944     } catch (Dali::DaliException e) {
90945       {
90946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90947       };
90948     } catch (...) {
90949       {
90950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90951       };
90952     }
90953   }
90954
90955   jresult = (void *)result;
90956   return jresult;
90957 }
90958
90959
90960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90961   void * jresult ;
90962   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90963   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90964   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90965
90966   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90967   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90968   if (!arg2) {
90969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90970     return 0;
90971   }
90972   {
90973     try {
90974       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90975     } catch (std::out_of_range& e) {
90976       {
90977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90978       };
90979     } catch (std::exception& e) {
90980       {
90981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90982       };
90983     } catch (Dali::DaliException e) {
90984       {
90985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90986       };
90987     } catch (...) {
90988       {
90989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90990       };
90991     }
90992   }
90993
90994   jresult = (void *)result;
90995   return jresult;
90996 }
90997
90998
90999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
91000   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
91001
91002   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
91003   {
91004     try {
91005       delete arg1;
91006     } catch (std::out_of_range& e) {
91007       {
91008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91009       };
91010     } catch (std::exception& e) {
91011       {
91012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91013       };
91014     } catch (Dali::DaliException e) {
91015       {
91016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91017       };
91018     } catch (...) {
91019       {
91020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91021       };
91022     }
91023   }
91024
91025 }
91026
91027
91028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
91029   void * jresult ;
91030   Dali::Toolkit::PageFactory *arg1 = 0 ;
91031   Dali::Vector2 *arg2 = 0 ;
91032   Dali::Toolkit::PageTurnPortraitView result;
91033
91034   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
91035   if (!arg1) {
91036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
91037     return 0;
91038   }
91039   arg2 = (Dali::Vector2 *)jarg2;
91040   if (!arg2) {
91041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91042     return 0;
91043   }
91044   {
91045     try {
91046       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
91047     } catch (std::out_of_range& e) {
91048       {
91049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91050       };
91051     } catch (std::exception& e) {
91052       {
91053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91054       };
91055     } catch (Dali::DaliException e) {
91056       {
91057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91058       };
91059     } catch (...) {
91060       {
91061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91062       };
91063     }
91064   }
91065
91066   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91067   return jresult;
91068 }
91069
91070
91071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
91072   void * jresult ;
91073   Dali::BaseHandle arg1 ;
91074   Dali::BaseHandle *argp1 ;
91075   Dali::Toolkit::PageTurnPortraitView result;
91076
91077   argp1 = (Dali::BaseHandle *)jarg1;
91078   if (!argp1) {
91079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91080     return 0;
91081   }
91082   arg1 = *argp1;
91083   {
91084     try {
91085       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91086     } catch (std::out_of_range& e) {
91087       {
91088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91089       };
91090     } catch (std::exception& e) {
91091       {
91092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91093       };
91094     } catch (Dali::DaliException e) {
91095       {
91096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91097       };
91098     } catch (...) {
91099       {
91100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91101       };
91102     }
91103   }
91104
91105   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91106   return jresult;
91107 }
91108
91109
91110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91111   int jresult ;
91112   int result;
91113
91114   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91115   jresult = (int)result;
91116   return jresult;
91117 }
91118
91119
91120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91121   int jresult ;
91122   int result;
91123
91124   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91125   jresult = (int)result;
91126   return jresult;
91127 }
91128
91129
91130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91131   int jresult ;
91132   int result;
91133
91134   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91135   jresult = (int)result;
91136   return jresult;
91137 }
91138
91139
91140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91141   void * jresult ;
91142   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91143
91144   {
91145     try {
91146       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91147     } catch (std::out_of_range& e) {
91148       {
91149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91150       };
91151     } catch (std::exception& e) {
91152       {
91153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91154       };
91155     } catch (Dali::DaliException e) {
91156       {
91157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91158       };
91159     } catch (...) {
91160       {
91161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91162       };
91163     }
91164   }
91165
91166   jresult = (void *)result;
91167   return jresult;
91168 }
91169
91170
91171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91172   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91173
91174   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91175   {
91176     try {
91177       delete arg1;
91178     } catch (std::out_of_range& e) {
91179       {
91180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91181       };
91182     } catch (std::exception& e) {
91183       {
91184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91185       };
91186     } catch (Dali::DaliException e) {
91187       {
91188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91189       };
91190     } catch (...) {
91191       {
91192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91193       };
91194     }
91195   }
91196
91197 }
91198
91199
91200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91201   void * jresult ;
91202   Dali::Toolkit::ToggleButton *result = 0 ;
91203
91204   {
91205     try {
91206       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91207     } catch (std::out_of_range& e) {
91208       {
91209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91210       };
91211     } catch (std::exception& e) {
91212       {
91213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91214       };
91215     } catch (Dali::DaliException e) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91218       };
91219     } catch (...) {
91220       {
91221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91222       };
91223     }
91224   }
91225
91226   jresult = (void *)result;
91227   return jresult;
91228 }
91229
91230
91231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91232   void * jresult ;
91233   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91234   Dali::Toolkit::ToggleButton *result = 0 ;
91235
91236   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91237   if (!arg1) {
91238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91239     return 0;
91240   }
91241   {
91242     try {
91243       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91244     } catch (std::out_of_range& e) {
91245       {
91246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91247       };
91248     } catch (std::exception& e) {
91249       {
91250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91251       };
91252     } catch (Dali::DaliException e) {
91253       {
91254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91255       };
91256     } catch (...) {
91257       {
91258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91259       };
91260     }
91261   }
91262
91263   jresult = (void *)result;
91264   return jresult;
91265 }
91266
91267
91268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91269   void * jresult ;
91270   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91271   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91272   Dali::Toolkit::ToggleButton *result = 0 ;
91273
91274   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91275   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91276   if (!arg2) {
91277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91278     return 0;
91279   }
91280   {
91281     try {
91282       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91283     } catch (std::out_of_range& e) {
91284       {
91285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91286       };
91287     } catch (std::exception& e) {
91288       {
91289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91290       };
91291     } catch (Dali::DaliException e) {
91292       {
91293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91294       };
91295     } catch (...) {
91296       {
91297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91298       };
91299     }
91300   }
91301
91302   jresult = (void *)result;
91303   return jresult;
91304 }
91305
91306
91307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91308   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91309
91310   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91311   {
91312     try {
91313       delete arg1;
91314     } catch (std::out_of_range& e) {
91315       {
91316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91317       };
91318     } catch (std::exception& e) {
91319       {
91320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91321       };
91322     } catch (Dali::DaliException e) {
91323       {
91324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91325       };
91326     } catch (...) {
91327       {
91328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91329       };
91330     }
91331   }
91332
91333 }
91334
91335
91336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91337   void * jresult ;
91338   Dali::Toolkit::ToggleButton result;
91339
91340   {
91341     try {
91342       result = Dali::Toolkit::ToggleButton::New();
91343     } catch (std::out_of_range& e) {
91344       {
91345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91346       };
91347     } catch (std::exception& e) {
91348       {
91349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91350       };
91351     } catch (Dali::DaliException e) {
91352       {
91353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91354       };
91355     } catch (...) {
91356       {
91357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91358       };
91359     }
91360   }
91361
91362   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91363   return jresult;
91364 }
91365
91366
91367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91368   void * jresult ;
91369   Dali::BaseHandle arg1 ;
91370   Dali::BaseHandle *argp1 ;
91371   Dali::Toolkit::ToggleButton result;
91372
91373   argp1 = (Dali::BaseHandle *)jarg1;
91374   if (!argp1) {
91375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91376     return 0;
91377   }
91378   arg1 = *argp1;
91379   {
91380     try {
91381       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91382     } catch (std::out_of_range& e) {
91383       {
91384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91385       };
91386     } catch (std::exception& e) {
91387       {
91388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91389       };
91390     } catch (Dali::DaliException e) {
91391       {
91392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91393       };
91394     } catch (...) {
91395       {
91396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91397       };
91398     }
91399   }
91400
91401   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91402   return jresult;
91403 }
91404
91405
91406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91407   void * jresult ;
91408   Dali::Toolkit::Visual::Base *result = 0 ;
91409
91410   {
91411     try {
91412       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91413     } catch (std::out_of_range& e) {
91414       {
91415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91416       };
91417     } catch (std::exception& e) {
91418       {
91419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91420       };
91421     } catch (Dali::DaliException e) {
91422       {
91423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91424       };
91425     } catch (...) {
91426       {
91427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91428       };
91429     }
91430   }
91431
91432   jresult = (void *)result;
91433   return jresult;
91434 }
91435
91436
91437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91438   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91439
91440   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91441   {
91442     try {
91443       delete arg1;
91444     } catch (std::out_of_range& e) {
91445       {
91446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91447       };
91448     } catch (std::exception& e) {
91449       {
91450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91451       };
91452     } catch (Dali::DaliException e) {
91453       {
91454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91455       };
91456     } catch (...) {
91457       {
91458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91459       };
91460     }
91461   }
91462
91463 }
91464
91465
91466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91467   void * jresult ;
91468   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91469   Dali::Toolkit::Visual::Base *result = 0 ;
91470
91471   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91472   if (!arg1) {
91473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91474     return 0;
91475   }
91476   {
91477     try {
91478       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91479     } catch (std::out_of_range& e) {
91480       {
91481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91482       };
91483     } catch (std::exception& e) {
91484       {
91485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91486       };
91487     } catch (Dali::DaliException e) {
91488       {
91489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91490       };
91491     } catch (...) {
91492       {
91493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91494       };
91495     }
91496   }
91497
91498   jresult = (void *)result;
91499   return jresult;
91500 }
91501
91502
91503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91504   void * jresult ;
91505   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91506   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91507   Dali::Toolkit::Visual::Base *result = 0 ;
91508
91509   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91510   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91511   if (!arg2) {
91512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91513     return 0;
91514   }
91515   {
91516     try {
91517       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91518     } catch (std::out_of_range& e) {
91519       {
91520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91521       };
91522     } catch (std::exception& e) {
91523       {
91524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91525       };
91526     } catch (Dali::DaliException e) {
91527       {
91528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91529       };
91530     } catch (...) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91533       };
91534     }
91535   }
91536
91537   jresult = (void *)result;
91538   return jresult;
91539 }
91540
91541
91542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91543   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91544   std::string *arg2 = 0 ;
91545
91546   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91547   if (!jarg2) {
91548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91549     return ;
91550   }
91551   std::string arg2_str(jarg2);
91552   arg2 = &arg2_str;
91553   {
91554     try {
91555       (arg1)->SetName((std::string const &)*arg2);
91556     } catch (std::out_of_range& e) {
91557       {
91558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91559       };
91560     } catch (std::exception& e) {
91561       {
91562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91563       };
91564     } catch (Dali::DaliException e) {
91565       {
91566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91567       };
91568     } catch (...) {
91569       {
91570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91571       };
91572     }
91573   }
91574
91575
91576   //argout typemap for const std::string&
91577
91578 }
91579
91580
91581 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91582   char * jresult ;
91583   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91584   std::string *result = 0 ;
91585
91586   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91587   {
91588     try {
91589       result = (std::string *) &(arg1)->GetName();
91590     } catch (std::out_of_range& e) {
91591       {
91592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91593       };
91594     } catch (std::exception& e) {
91595       {
91596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91597       };
91598     } catch (Dali::DaliException e) {
91599       {
91600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91601       };
91602     } catch (...) {
91603       {
91604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91605       };
91606     }
91607   }
91608
91609   jresult = SWIG_csharp_string_callback(result->c_str());
91610   return jresult;
91611 }
91612
91613
91614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91615   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91616   Dali::Property::Map *arg2 = 0 ;
91617   Dali::Size arg3 ;
91618   Dali::Size *argp3 ;
91619
91620   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91621   arg2 = (Dali::Property::Map *)jarg2;
91622   if (!arg2) {
91623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91624     return ;
91625   }
91626   argp3 = (Dali::Size *)jarg3;
91627   if (!argp3) {
91628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91629     return ;
91630   }
91631   arg3 = *argp3;
91632   {
91633     try {
91634       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91635     } catch (std::out_of_range& e) {
91636       {
91637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91638       };
91639     } catch (std::exception& e) {
91640       {
91641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91642       };
91643     } catch (Dali::DaliException e) {
91644       {
91645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91646       };
91647     } catch (...) {
91648       {
91649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91650       };
91651     }
91652   }
91653
91654 }
91655
91656
91657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91658   float jresult ;
91659   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91660   float arg2 ;
91661   float result;
91662
91663   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91664   arg2 = (float)jarg2;
91665   {
91666     try {
91667       result = (float)(arg1)->GetHeightForWidth(arg2);
91668     } catch (std::out_of_range& e) {
91669       {
91670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91671       };
91672     } catch (std::exception& e) {
91673       {
91674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91675       };
91676     } catch (Dali::DaliException e) {
91677       {
91678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91679       };
91680     } catch (...) {
91681       {
91682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91683       };
91684     }
91685   }
91686
91687   jresult = result;
91688   return jresult;
91689 }
91690
91691
91692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91693   float jresult ;
91694   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91695   float arg2 ;
91696   float result;
91697
91698   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91699   arg2 = (float)jarg2;
91700   {
91701     try {
91702       result = (float)(arg1)->GetWidthForHeight(arg2);
91703     } catch (std::out_of_range& e) {
91704       {
91705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91706       };
91707     } catch (std::exception& e) {
91708       {
91709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91710       };
91711     } catch (Dali::DaliException e) {
91712       {
91713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91714       };
91715     } catch (...) {
91716       {
91717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91718       };
91719     }
91720   }
91721
91722   jresult = result;
91723   return jresult;
91724 }
91725
91726
91727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91728   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91729   Dali::Vector2 *arg2 = 0 ;
91730
91731   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91732   arg2 = (Dali::Vector2 *)jarg2;
91733   if (!arg2) {
91734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91735     return ;
91736   }
91737   {
91738     try {
91739       (arg1)->GetNaturalSize(*arg2);
91740     } catch (std::out_of_range& e) {
91741       {
91742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91743       };
91744     } catch (std::exception& e) {
91745       {
91746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91747       };
91748     } catch (Dali::DaliException e) {
91749       {
91750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91751       };
91752     } catch (...) {
91753       {
91754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91755       };
91756     }
91757   }
91758
91759 }
91760
91761
91762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91763   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91764   float arg2 ;
91765
91766   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91767   arg2 = (int)jarg2;
91768   {
91769     try {
91770       (arg1)->SetDepthIndex(arg2);
91771     } catch (std::out_of_range& e) {
91772       {
91773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91774       };
91775     } catch (std::exception& e) {
91776       {
91777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91778       };
91779     } catch (Dali::DaliException e) {
91780       {
91781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91782       };
91783     } catch (...) {
91784       {
91785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91786       };
91787     }
91788   }
91789
91790 }
91791
91792
91793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91794   int jresult ;
91795   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91796   int result;
91797
91798   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91799   {
91800     try {
91801       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91802     } catch (std::out_of_range& e) {
91803       {
91804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91805       };
91806     } catch (std::exception& e) {
91807       {
91808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91809       };
91810     } catch (Dali::DaliException e) {
91811       {
91812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91813       };
91814     } catch (...) {
91815       {
91816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91817       };
91818     }
91819   }
91820
91821   jresult = result;
91822   return jresult;
91823 }
91824
91825
91826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91827   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91828   Dali::Property::Map *arg2 = 0 ;
91829
91830   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91831   arg2 = (Dali::Property::Map *)jarg2;
91832   if (!arg2) {
91833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91834     return ;
91835   }
91836   {
91837     try {
91838       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91839     } catch (std::out_of_range& e) {
91840       {
91841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91842       };
91843     } catch (std::exception& e) {
91844       {
91845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91846       };
91847     } catch (Dali::DaliException e) {
91848       {
91849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91850       };
91851     } catch (...) {
91852       {
91853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91854       };
91855     }
91856   }
91857
91858 }
91859
91860
91861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91862   void * jresult ;
91863   Dali::Toolkit::VisualFactory result;
91864
91865   {
91866     try {
91867       result = Dali::Toolkit::VisualFactory::Get();
91868     } catch (std::out_of_range& e) {
91869       {
91870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91871       };
91872     } catch (std::exception& e) {
91873       {
91874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91875       };
91876     } catch (Dali::DaliException e) {
91877       {
91878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91879       };
91880     } catch (...) {
91881       {
91882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91883       };
91884     }
91885   }
91886
91887   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91888   return jresult;
91889 }
91890
91891
91892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91893   void * jresult ;
91894   Dali::Toolkit::VisualFactory *result = 0 ;
91895
91896   {
91897     try {
91898       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91899     } catch (std::out_of_range& e) {
91900       {
91901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91902       };
91903     } catch (std::exception& e) {
91904       {
91905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91906       };
91907     } catch (Dali::DaliException e) {
91908       {
91909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91910       };
91911     } catch (...) {
91912       {
91913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91914       };
91915     }
91916   }
91917
91918   jresult = (void *)result;
91919   return jresult;
91920 }
91921
91922
91923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91924   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91925
91926   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91927   {
91928     try {
91929       delete arg1;
91930     } catch (std::out_of_range& e) {
91931       {
91932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91933       };
91934     } catch (std::exception& e) {
91935       {
91936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91937       };
91938     } catch (Dali::DaliException e) {
91939       {
91940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91941       };
91942     } catch (...) {
91943       {
91944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91945       };
91946     }
91947   }
91948
91949 }
91950
91951
91952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91953   void * jresult ;
91954   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91955   Dali::Toolkit::VisualFactory *result = 0 ;
91956
91957   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91958   if (!arg1) {
91959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91960     return 0;
91961   }
91962   {
91963     try {
91964       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91965     } catch (std::out_of_range& e) {
91966       {
91967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91968       };
91969     } catch (std::exception& e) {
91970       {
91971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91972       };
91973     } catch (Dali::DaliException e) {
91974       {
91975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91976       };
91977     } catch (...) {
91978       {
91979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91980       };
91981     }
91982   }
91983
91984   jresult = (void *)result;
91985   return jresult;
91986 }
91987
91988
91989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91990   void * jresult ;
91991   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91992   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91993   Dali::Toolkit::VisualFactory *result = 0 ;
91994
91995   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91996   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91997   if (!arg2) {
91998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91999     return 0;
92000   }
92001   {
92002     try {
92003       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
92004     } catch (std::out_of_range& e) {
92005       {
92006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92007       };
92008     } catch (std::exception& e) {
92009       {
92010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92011       };
92012     } catch (Dali::DaliException e) {
92013       {
92014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92015       };
92016     } catch (...) {
92017       {
92018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92019       };
92020     }
92021   }
92022
92023   jresult = (void *)result;
92024   return jresult;
92025 }
92026
92027
92028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
92029   void * jresult ;
92030   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92031   Dali::Property::Map *arg2 = 0 ;
92032   Dali::Toolkit::Visual::Base result;
92033
92034   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92035   arg2 = (Dali::Property::Map *)jarg2;
92036   if (!arg2) {
92037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
92038     return 0;
92039   }
92040   {
92041     try {
92042       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
92043     } catch (std::out_of_range& e) {
92044       {
92045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92046       };
92047     } catch (std::exception& e) {
92048       {
92049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92050       };
92051     } catch (Dali::DaliException e) {
92052       {
92053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92054       };
92055     } catch (...) {
92056       {
92057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92058       };
92059     }
92060   }
92061
92062   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92063   return jresult;
92064 }
92065
92066
92067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
92068   void * jresult ;
92069   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92070   Dali::Image *arg2 = 0 ;
92071   Dali::Toolkit::Visual::Base result;
92072
92073   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92074   arg2 = (Dali::Image *)jarg2;
92075   if (!arg2) {
92076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92077     return 0;
92078   }
92079   {
92080     try {
92081       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92082     } catch (std::out_of_range& e) {
92083       {
92084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92085       };
92086     } catch (std::exception& e) {
92087       {
92088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92089       };
92090     } catch (Dali::DaliException e) {
92091       {
92092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92093       };
92094     } catch (...) {
92095       {
92096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92097       };
92098     }
92099   }
92100
92101   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92102   return jresult;
92103 }
92104
92105
92106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92107   void * jresult ;
92108   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92109   std::string *arg2 = 0 ;
92110   Dali::ImageDimensions arg3 ;
92111   Dali::ImageDimensions *argp3 ;
92112   Dali::Toolkit::Visual::Base result;
92113
92114   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92115   if (!jarg2) {
92116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92117     return 0;
92118   }
92119   std::string arg2_str(jarg2);
92120   arg2 = &arg2_str;
92121   argp3 = (Dali::ImageDimensions *)jarg3;
92122   if (!argp3) {
92123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92124     return 0;
92125   }
92126   arg3 = *argp3;
92127   {
92128     try {
92129       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
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 = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92150
92151   //argout typemap for const std::string&
92152
92153   return jresult;
92154 }
92155
92156
92157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92158   void * jresult ;
92159   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92160
92161   {
92162     try {
92163       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92164     } catch (std::out_of_range& e) {
92165       {
92166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92167       };
92168     } catch (std::exception& e) {
92169       {
92170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92171       };
92172     } catch (Dali::DaliException e) {
92173       {
92174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92175       };
92176     } catch (...) {
92177       {
92178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92179       };
92180     }
92181   }
92182
92183   jresult = (void *)result;
92184   return jresult;
92185 }
92186
92187
92188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92189   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92190
92191   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92192   {
92193     try {
92194       delete arg1;
92195     } catch (std::out_of_range& e) {
92196       {
92197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92198       };
92199     } catch (std::exception& e) {
92200       {
92201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92202       };
92203     } catch (Dali::DaliException e) {
92204       {
92205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92206       };
92207     } catch (...) {
92208       {
92209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92210       };
92211     }
92212   }
92213
92214 }
92215
92216
92217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92218   void * jresult ;
92219   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92220   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92221
92222   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92223   if (!arg1) {
92224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92225     return 0;
92226   }
92227   {
92228     try {
92229       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92230     } catch (std::out_of_range& e) {
92231       {
92232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92233       };
92234     } catch (std::exception& e) {
92235       {
92236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92237       };
92238     } catch (Dali::DaliException e) {
92239       {
92240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92241       };
92242     } catch (...) {
92243       {
92244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92245       };
92246     }
92247   }
92248
92249   jresult = (void *)result;
92250   return jresult;
92251 }
92252
92253
92254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92255   void * jresult ;
92256   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92257   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92258   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92259
92260   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92261   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92262   if (!arg2) {
92263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92264     return 0;
92265   }
92266   {
92267     try {
92268       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92269     } catch (std::out_of_range& e) {
92270       {
92271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92272       };
92273     } catch (std::exception& e) {
92274       {
92275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92276       };
92277     } catch (Dali::DaliException e) {
92278       {
92279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92280       };
92281     } catch (...) {
92282       {
92283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92284       };
92285     }
92286   }
92287
92288   jresult = (void *)result;
92289   return jresult;
92290 }
92291
92292
92293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92294   void * jresult ;
92295   Dali::Toolkit::AsyncImageLoader result;
92296
92297   {
92298     try {
92299       result = Dali::Toolkit::AsyncImageLoader::New();
92300     } catch (std::out_of_range& e) {
92301       {
92302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92303       };
92304     } catch (std::exception& e) {
92305       {
92306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92307       };
92308     } catch (Dali::DaliException e) {
92309       {
92310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92311       };
92312     } catch (...) {
92313       {
92314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92315       };
92316     }
92317   }
92318
92319   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92320   return jresult;
92321 }
92322
92323
92324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92325   void * jresult ;
92326   Dali::BaseHandle arg1 ;
92327   Dali::BaseHandle *argp1 ;
92328   Dali::Toolkit::AsyncImageLoader result;
92329
92330   argp1 = (Dali::BaseHandle *)jarg1;
92331   if (!argp1) {
92332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92333     return 0;
92334   }
92335   arg1 = *argp1;
92336   {
92337     try {
92338       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92339     } catch (std::out_of_range& e) {
92340       {
92341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92342       };
92343     } catch (std::exception& e) {
92344       {
92345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92346       };
92347     } catch (Dali::DaliException e) {
92348       {
92349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92350       };
92351     } catch (...) {
92352       {
92353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92354       };
92355     }
92356   }
92357
92358   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92359   return jresult;
92360 }
92361
92362
92363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92364   unsigned int jresult ;
92365   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92366   std::string *arg2 = 0 ;
92367   uint32_t result;
92368
92369   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92370   if (!jarg2) {
92371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92372     return 0;
92373   }
92374   std::string arg2_str(jarg2);
92375   arg2 = &arg2_str;
92376   {
92377     try {
92378       result = (arg1)->Load((std::string const &)*arg2);
92379     } catch (std::out_of_range& e) {
92380       {
92381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92382       };
92383     } catch (std::exception& e) {
92384       {
92385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92386       };
92387     } catch (Dali::DaliException e) {
92388       {
92389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92390       };
92391     } catch (...) {
92392       {
92393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92394       };
92395     }
92396   }
92397
92398   jresult = result;
92399
92400   //argout typemap for const std::string&
92401
92402   return jresult;
92403 }
92404
92405
92406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92407   unsigned int jresult ;
92408   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92409   std::string *arg2 = 0 ;
92410   Dali::ImageDimensions arg3 ;
92411   Dali::ImageDimensions *argp3 ;
92412   uint32_t result;
92413
92414   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92415   if (!jarg2) {
92416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92417     return 0;
92418   }
92419   std::string arg2_str(jarg2);
92420   arg2 = &arg2_str;
92421   argp3 = (Dali::ImageDimensions *)jarg3;
92422   if (!argp3) {
92423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92424     return 0;
92425   }
92426   arg3 = *argp3;
92427   {
92428     try {
92429       result = (arg1)->Load((std::string const &)*arg2,arg3);
92430     } catch (std::out_of_range& e) {
92431       {
92432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92433       };
92434     } catch (std::exception& e) {
92435       {
92436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92437       };
92438     } catch (Dali::DaliException e) {
92439       {
92440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92441       };
92442     } catch (...) {
92443       {
92444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92445       };
92446     }
92447   }
92448
92449   jresult = result;
92450
92451   //argout typemap for const std::string&
92452
92453   return jresult;
92454 }
92455
92456
92457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92458   unsigned int jresult ;
92459   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92460   std::string *arg2 = 0 ;
92461   Dali::ImageDimensions arg3 ;
92462   Dali::FittingMode::Type arg4 ;
92463   Dali::SamplingMode::Type arg5 ;
92464   bool arg6 ;
92465   Dali::ImageDimensions *argp3 ;
92466   uint32_t result;
92467
92468   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92469   if (!jarg2) {
92470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92471     return 0;
92472   }
92473   std::string arg2_str(jarg2);
92474   arg2 = &arg2_str;
92475   argp3 = (Dali::ImageDimensions *)jarg3;
92476   if (!argp3) {
92477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92478     return 0;
92479   }
92480   arg3 = *argp3;
92481   arg4 = (Dali::FittingMode::Type)jarg4;
92482   arg5 = (Dali::SamplingMode::Type)jarg5;
92483   arg6 = jarg6 ? true : false;
92484   {
92485     try {
92486       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92487     } catch (std::out_of_range& e) {
92488       {
92489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92490       };
92491     } catch (std::exception& e) {
92492       {
92493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92494       };
92495     } catch (Dali::DaliException e) {
92496       {
92497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92498       };
92499     } catch (...) {
92500       {
92501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92502       };
92503     }
92504   }
92505
92506   jresult = result;
92507
92508   //argout typemap for const std::string&
92509
92510   return jresult;
92511 }
92512
92513
92514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92515   unsigned int jresult ;
92516   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92517   uint32_t arg2 ;
92518   bool result;
92519
92520   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92521   arg2 = (uint32_t)jarg2;
92522   {
92523     try {
92524       result = (bool)(arg1)->Cancel(arg2);
92525     } catch (std::out_of_range& e) {
92526       {
92527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92528       };
92529     } catch (std::exception& e) {
92530       {
92531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92532       };
92533     } catch (Dali::DaliException e) {
92534       {
92535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92536       };
92537     } catch (...) {
92538       {
92539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92540       };
92541     }
92542   }
92543
92544   jresult = result;
92545   return jresult;
92546 }
92547
92548
92549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92550   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92551
92552   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92553   {
92554     try {
92555       (arg1)->CancelAll();
92556     } catch (std::out_of_range& e) {
92557       {
92558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92559       };
92560     } catch (std::exception& e) {
92561       {
92562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92563       };
92564     } catch (Dali::DaliException e) {
92565       {
92566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92567       };
92568     } catch (...) {
92569       {
92570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92571       };
92572     }
92573   }
92574
92575 }
92576
92577
92578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92579   void * jresult ;
92580   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92581   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92582
92583   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92584   {
92585     try {
92586       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92587     } catch (std::out_of_range& e) {
92588       {
92589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92590       };
92591     } catch (std::exception& e) {
92592       {
92593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92594       };
92595     } catch (Dali::DaliException e) {
92596       {
92597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92598       };
92599     } catch (...) {
92600       {
92601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92602       };
92603     }
92604   }
92605
92606   jresult = (void *)result;
92607   return jresult;
92608 }
92609
92610
92611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92612   void * jresult ;
92613   std::string *arg1 = 0 ;
92614   Dali::PixelData result;
92615
92616   if (!jarg1) {
92617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92618     return 0;
92619   }
92620   std::string arg1_str(jarg1);
92621   arg1 = &arg1_str;
92622   {
92623     try {
92624       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92625     } catch (std::out_of_range& e) {
92626       {
92627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92628       };
92629     } catch (std::exception& e) {
92630       {
92631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92632       };
92633     } catch (Dali::DaliException e) {
92634       {
92635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92636       };
92637     } catch (...) {
92638       {
92639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92640       };
92641     }
92642   }
92643
92644   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92645
92646   //argout typemap for const std::string&
92647
92648   return jresult;
92649 }
92650
92651
92652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92653   void * jresult ;
92654   std::string *arg1 = 0 ;
92655   Dali::ImageDimensions arg2 ;
92656   Dali::ImageDimensions *argp2 ;
92657   Dali::PixelData result;
92658
92659   if (!jarg1) {
92660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92661     return 0;
92662   }
92663   std::string arg1_str(jarg1);
92664   arg1 = &arg1_str;
92665   argp2 = (Dali::ImageDimensions *)jarg2;
92666   if (!argp2) {
92667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92668     return 0;
92669   }
92670   arg2 = *argp2;
92671   {
92672     try {
92673       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92674     } catch (std::out_of_range& e) {
92675       {
92676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92677       };
92678     } catch (std::exception& e) {
92679       {
92680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92681       };
92682     } catch (Dali::DaliException e) {
92683       {
92684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92685       };
92686     } catch (...) {
92687       {
92688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92689       };
92690     }
92691   }
92692
92693   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92694
92695   //argout typemap for const std::string&
92696
92697   return jresult;
92698 }
92699
92700
92701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92702   void * jresult ;
92703   std::string *arg1 = 0 ;
92704   Dali::ImageDimensions arg2 ;
92705   Dali::FittingMode::Type arg3 ;
92706   Dali::SamplingMode::Type arg4 ;
92707   bool arg5 ;
92708   Dali::ImageDimensions *argp2 ;
92709   Dali::PixelData result;
92710
92711   if (!jarg1) {
92712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92713     return 0;
92714   }
92715   std::string arg1_str(jarg1);
92716   arg1 = &arg1_str;
92717   argp2 = (Dali::ImageDimensions *)jarg2;
92718   if (!argp2) {
92719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92720     return 0;
92721   }
92722   arg2 = *argp2;
92723   arg3 = (Dali::FittingMode::Type)jarg3;
92724   arg4 = (Dali::SamplingMode::Type)jarg4;
92725   arg5 = jarg5 ? true : false;
92726   {
92727     try {
92728       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92729     } catch (std::out_of_range& e) {
92730       {
92731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92732       };
92733     } catch (std::exception& e) {
92734       {
92735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92736       };
92737     } catch (Dali::DaliException e) {
92738       {
92739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92740       };
92741     } catch (...) {
92742       {
92743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92744       };
92745     }
92746   }
92747
92748   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92749
92750   //argout typemap for const std::string&
92751
92752   return jresult;
92753 }
92754
92755
92756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92757   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92758
92759   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92760   {
92761     try {
92762       delete arg1;
92763     } catch (std::out_of_range& e) {
92764       {
92765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92766       };
92767     } catch (std::exception& e) {
92768       {
92769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92770       };
92771     } catch (Dali::DaliException e) {
92772       {
92773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92774       };
92775     } catch (...) {
92776       {
92777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92778       };
92779     }
92780   }
92781
92782 }
92783
92784
92785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92786   void * jresult ;
92787   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92788   Dali::Actor arg2 ;
92789   Dali::Actor arg3 ;
92790   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92791   Dali::Actor *argp2 ;
92792   Dali::Actor *argp3 ;
92793   Dali::Actor result;
92794
92795   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92796   argp2 = (Dali::Actor *)jarg2;
92797   if (!argp2) {
92798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92799     return 0;
92800   }
92801   arg2 = *argp2;
92802   argp3 = (Dali::Actor *)jarg3;
92803   if (!argp3) {
92804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92805     return 0;
92806   }
92807   arg3 = *argp3;
92808   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92809   {
92810     try {
92811       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92812     } catch (std::out_of_range& e) {
92813       {
92814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92815       };
92816     } catch (std::exception& e) {
92817       {
92818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92819       };
92820     } catch (Dali::DaliException e) {
92821       {
92822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92823       };
92824     } catch (...) {
92825       {
92826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92827       };
92828     }
92829   }
92830
92831   jresult = new Dali::Actor((const Dali::Actor &)result);
92832   return jresult;
92833 }
92834
92835
92836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92837   void * jresult ;
92838   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92839
92840   {
92841     try {
92842       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92843     } catch (std::out_of_range& e) {
92844       {
92845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92846       };
92847     } catch (std::exception& e) {
92848       {
92849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92850       };
92851     } catch (Dali::DaliException e) {
92852       {
92853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92854       };
92855     } catch (...) {
92856       {
92857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92858       };
92859     }
92860   }
92861
92862   jresult = (void *)result;
92863   return jresult;
92864 }
92865
92866
92867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92868   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92869   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92870   if (director) {
92871     director->swig_connect_director(callback0);
92872   }
92873 }
92874
92875
92876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92877   KeyboardFocusManager arg1 ;
92878   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92879   KeyboardFocusManager *argp1 ;
92880
92881   argp1 = (KeyboardFocusManager *)jarg1;
92882   if (!argp1) {
92883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92884     return ;
92885   }
92886   arg1 = *argp1;
92887   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92888   if (!arg2) {
92889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92890     return ;
92891   }
92892   {
92893     try {
92894       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92895     } catch (std::out_of_range& e) {
92896       {
92897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92898       };
92899     } catch (std::exception& e) {
92900       {
92901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92902       };
92903     } catch (Dali::DaliException e) {
92904       {
92905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92906       };
92907     } catch (...) {
92908       {
92909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92910       };
92911     }
92912   }
92913
92914 }
92915
92916
92917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92918   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92919
92920   arg1 = (std::vector< unsigned int > *)jarg1;
92921   {
92922     try {
92923       (arg1)->clear();
92924     } catch (std::out_of_range& e) {
92925       {
92926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92927       };
92928     } catch (std::exception& e) {
92929       {
92930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92931       };
92932     } catch (Dali::DaliException e) {
92933       {
92934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92935       };
92936     } catch (...) {
92937       {
92938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92939       };
92940     }
92941   }
92942
92943 }
92944
92945
92946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92947   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92948   unsigned int *arg2 = 0 ;
92949   unsigned int temp2 ;
92950
92951   arg1 = (std::vector< unsigned int > *)jarg1;
92952   temp2 = (unsigned int)jarg2;
92953   arg2 = &temp2;
92954   {
92955     try {
92956       (arg1)->push_back((unsigned int const &)*arg2);
92957     } catch (std::out_of_range& e) {
92958       {
92959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92960       };
92961     } catch (std::exception& e) {
92962       {
92963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92964       };
92965     } catch (Dali::DaliException e) {
92966       {
92967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92968       };
92969     } catch (...) {
92970       {
92971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92972       };
92973     }
92974   }
92975
92976 }
92977
92978
92979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92980   unsigned long jresult ;
92981   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92982   std::vector< unsigned int >::size_type result;
92983
92984   arg1 = (std::vector< unsigned int > *)jarg1;
92985   {
92986     try {
92987       result = ((std::vector< unsigned int > const *)arg1)->size();
92988     } catch (std::out_of_range& e) {
92989       {
92990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92991       };
92992     } catch (std::exception& e) {
92993       {
92994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92995       };
92996     } catch (Dali::DaliException e) {
92997       {
92998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92999       };
93000     } catch (...) {
93001       {
93002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93003       };
93004     }
93005   }
93006
93007   jresult = (unsigned long)result;
93008   return jresult;
93009 }
93010
93011
93012 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
93013   unsigned long jresult ;
93014   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93015   std::vector< unsigned int >::size_type result;
93016
93017   arg1 = (std::vector< unsigned int > *)jarg1;
93018   {
93019     try {
93020       result = ((std::vector< unsigned int > const *)arg1)->capacity();
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 = (unsigned long)result;
93041   return jresult;
93042 }
93043
93044
93045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
93046   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93047   std::vector< unsigned int >::size_type arg2 ;
93048
93049   arg1 = (std::vector< unsigned int > *)jarg1;
93050   arg2 = (std::vector< unsigned int >::size_type)jarg2;
93051   {
93052     try {
93053       (arg1)->reserve(arg2);
93054     } catch (std::out_of_range& e) {
93055       {
93056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93057       };
93058     } catch (std::exception& e) {
93059       {
93060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93061       };
93062     } catch (Dali::DaliException e) {
93063       {
93064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93065       };
93066     } catch (...) {
93067       {
93068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93069       };
93070     }
93071   }
93072
93073 }
93074
93075
93076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93077   void * jresult ;
93078   std::vector< unsigned int > *result = 0 ;
93079
93080   {
93081     try {
93082       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93083     } catch (std::out_of_range& e) {
93084       {
93085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93086       };
93087     } catch (std::exception& e) {
93088       {
93089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93090       };
93091     } catch (Dali::DaliException e) {
93092       {
93093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93094       };
93095     } catch (...) {
93096       {
93097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93098       };
93099     }
93100   }
93101
93102   jresult = (void *)result;
93103   return jresult;
93104 }
93105
93106
93107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93108   void * jresult ;
93109   std::vector< unsigned int > *arg1 = 0 ;
93110   std::vector< unsigned int > *result = 0 ;
93111
93112   arg1 = (std::vector< unsigned int > *)jarg1;
93113   if (!arg1) {
93114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93115     return 0;
93116   }
93117   {
93118     try {
93119       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93120     } catch (std::out_of_range& e) {
93121       {
93122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93123       };
93124     } catch (std::exception& e) {
93125       {
93126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93127       };
93128     } catch (Dali::DaliException e) {
93129       {
93130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93131       };
93132     } catch (...) {
93133       {
93134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93135       };
93136     }
93137   }
93138
93139   jresult = (void *)result;
93140   return jresult;
93141 }
93142
93143
93144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93145   void * jresult ;
93146   int arg1 ;
93147   std::vector< unsigned int > *result = 0 ;
93148
93149   arg1 = (int)jarg1;
93150   {
93151     try {
93152       try {
93153         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93154       }
93155       catch(std::out_of_range &_e) {
93156         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93157         return 0;
93158       }
93159
93160     } catch (std::out_of_range& e) {
93161       {
93162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93163       };
93164     } catch (std::exception& e) {
93165       {
93166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93167       };
93168     } catch (Dali::DaliException e) {
93169       {
93170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93171       };
93172     } catch (...) {
93173       {
93174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93175       };
93176     }
93177   }
93178
93179   jresult = (void *)result;
93180   return jresult;
93181 }
93182
93183
93184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93185   unsigned int jresult ;
93186   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93187   int arg2 ;
93188   unsigned int result;
93189
93190   arg1 = (std::vector< unsigned int > *)jarg1;
93191   arg2 = (int)jarg2;
93192   {
93193     try {
93194       try {
93195         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93196       }
93197       catch(std::out_of_range &_e) {
93198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93199         return 0;
93200       }
93201
93202     } catch (std::out_of_range& e) {
93203       {
93204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93205       };
93206     } catch (std::exception& e) {
93207       {
93208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93209       };
93210     } catch (Dali::DaliException e) {
93211       {
93212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93213       };
93214     } catch (...) {
93215       {
93216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93217       };
93218     }
93219   }
93220
93221   jresult = result;
93222   return jresult;
93223 }
93224
93225
93226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93227   unsigned int jresult ;
93228   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93229   int arg2 ;
93230   unsigned int *result = 0 ;
93231
93232   arg1 = (std::vector< unsigned int > *)jarg1;
93233   arg2 = (int)jarg2;
93234   {
93235     try {
93236       try {
93237         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93238       }
93239       catch(std::out_of_range &_e) {
93240         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93241         return 0;
93242       }
93243
93244     } catch (std::out_of_range& e) {
93245       {
93246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93247       };
93248     } catch (std::exception& e) {
93249       {
93250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93251       };
93252     } catch (Dali::DaliException e) {
93253       {
93254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93255       };
93256     } catch (...) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93259       };
93260     }
93261   }
93262
93263   jresult = *result;
93264   return jresult;
93265 }
93266
93267
93268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93269   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93270   int arg2 ;
93271   unsigned int *arg3 = 0 ;
93272   unsigned int temp3 ;
93273
93274   arg1 = (std::vector< unsigned int > *)jarg1;
93275   arg2 = (int)jarg2;
93276   temp3 = (unsigned int)jarg3;
93277   arg3 = &temp3;
93278   {
93279     try {
93280       try {
93281         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93282       }
93283       catch(std::out_of_range &_e) {
93284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93285         return ;
93286       }
93287
93288     } catch (std::out_of_range& e) {
93289       {
93290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93291       };
93292     } catch (std::exception& e) {
93293       {
93294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93295       };
93296     } catch (Dali::DaliException e) {
93297       {
93298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93299       };
93300     } catch (...) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93303       };
93304     }
93305   }
93306
93307 }
93308
93309
93310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93311   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93312   std::vector< unsigned int > *arg2 = 0 ;
93313
93314   arg1 = (std::vector< unsigned int > *)jarg1;
93315   arg2 = (std::vector< unsigned int > *)jarg2;
93316   if (!arg2) {
93317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93318     return ;
93319   }
93320   {
93321     try {
93322       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93323     } catch (std::out_of_range& e) {
93324       {
93325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93326       };
93327     } catch (std::exception& e) {
93328       {
93329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93330       };
93331     } catch (Dali::DaliException e) {
93332       {
93333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93334       };
93335     } catch (...) {
93336       {
93337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93338       };
93339     }
93340   }
93341
93342 }
93343
93344
93345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93346   void * jresult ;
93347   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93348   int arg2 ;
93349   int arg3 ;
93350   std::vector< unsigned int > *result = 0 ;
93351
93352   arg1 = (std::vector< unsigned int > *)jarg1;
93353   arg2 = (int)jarg2;
93354   arg3 = (int)jarg3;
93355   {
93356     try {
93357       try {
93358         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93359       }
93360       catch(std::out_of_range &_e) {
93361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93362         return 0;
93363       }
93364       catch(std::invalid_argument &_e) {
93365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93366         return 0;
93367       }
93368
93369     } catch (std::out_of_range& e) {
93370       {
93371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93372       };
93373     } catch (std::exception& e) {
93374       {
93375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93376       };
93377     } catch (Dali::DaliException e) {
93378       {
93379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93380       };
93381     } catch (...) {
93382       {
93383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93384       };
93385     }
93386   }
93387
93388   jresult = (void *)result;
93389   return jresult;
93390 }
93391
93392
93393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93394   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93395   int arg2 ;
93396   unsigned int *arg3 = 0 ;
93397   unsigned int temp3 ;
93398
93399   arg1 = (std::vector< unsigned int > *)jarg1;
93400   arg2 = (int)jarg2;
93401   temp3 = (unsigned int)jarg3;
93402   arg3 = &temp3;
93403   {
93404     try {
93405       try {
93406         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93407       }
93408       catch(std::out_of_range &_e) {
93409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93410         return ;
93411       }
93412
93413     } catch (std::out_of_range& e) {
93414       {
93415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93416       };
93417     } catch (std::exception& e) {
93418       {
93419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93420       };
93421     } catch (Dali::DaliException e) {
93422       {
93423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93424       };
93425     } catch (...) {
93426       {
93427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93428       };
93429     }
93430   }
93431
93432 }
93433
93434
93435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93436   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93437   int arg2 ;
93438   std::vector< unsigned int > *arg3 = 0 ;
93439
93440   arg1 = (std::vector< unsigned int > *)jarg1;
93441   arg2 = (int)jarg2;
93442   arg3 = (std::vector< unsigned int > *)jarg3;
93443   if (!arg3) {
93444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93445     return ;
93446   }
93447   {
93448     try {
93449       try {
93450         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93451       }
93452       catch(std::out_of_range &_e) {
93453         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93454         return ;
93455       }
93456
93457     } catch (std::out_of_range& e) {
93458       {
93459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93460       };
93461     } catch (std::exception& e) {
93462       {
93463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93464       };
93465     } catch (Dali::DaliException e) {
93466       {
93467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93468       };
93469     } catch (...) {
93470       {
93471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93472       };
93473     }
93474   }
93475
93476 }
93477
93478
93479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93480   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93481   int arg2 ;
93482
93483   arg1 = (std::vector< unsigned int > *)jarg1;
93484   arg2 = (int)jarg2;
93485   {
93486     try {
93487       try {
93488         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93489       }
93490       catch(std::out_of_range &_e) {
93491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93492         return ;
93493       }
93494
93495     } catch (std::out_of_range& e) {
93496       {
93497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93498       };
93499     } catch (std::exception& e) {
93500       {
93501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93502       };
93503     } catch (Dali::DaliException e) {
93504       {
93505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93506       };
93507     } catch (...) {
93508       {
93509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93510       };
93511     }
93512   }
93513
93514 }
93515
93516
93517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93518   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93519   int arg2 ;
93520   int arg3 ;
93521
93522   arg1 = (std::vector< unsigned int > *)jarg1;
93523   arg2 = (int)jarg2;
93524   arg3 = (int)jarg3;
93525   {
93526     try {
93527       try {
93528         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93529       }
93530       catch(std::out_of_range &_e) {
93531         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93532         return ;
93533       }
93534       catch(std::invalid_argument &_e) {
93535         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93536         return ;
93537       }
93538
93539     } catch (std::out_of_range& e) {
93540       {
93541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93542       };
93543     } catch (std::exception& e) {
93544       {
93545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93546       };
93547     } catch (Dali::DaliException e) {
93548       {
93549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93550       };
93551     } catch (...) {
93552       {
93553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93554       };
93555     }
93556   }
93557
93558 }
93559
93560
93561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93562   void * jresult ;
93563   unsigned int *arg1 = 0 ;
93564   int arg2 ;
93565   unsigned int temp1 ;
93566   std::vector< unsigned int > *result = 0 ;
93567
93568   temp1 = (unsigned int)jarg1;
93569   arg1 = &temp1;
93570   arg2 = (int)jarg2;
93571   {
93572     try {
93573       try {
93574         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93575       }
93576       catch(std::out_of_range &_e) {
93577         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93578         return 0;
93579       }
93580
93581     } catch (std::out_of_range& e) {
93582       {
93583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93584       };
93585     } catch (std::exception& e) {
93586       {
93587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93588       };
93589     } catch (Dali::DaliException e) {
93590       {
93591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93592       };
93593     } catch (...) {
93594       {
93595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93596       };
93597     }
93598   }
93599
93600   jresult = (void *)result;
93601   return jresult;
93602 }
93603
93604
93605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93606   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93607
93608   arg1 = (std::vector< unsigned int > *)jarg1;
93609   {
93610     try {
93611       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93612     } catch (std::out_of_range& e) {
93613       {
93614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93615       };
93616     } catch (std::exception& e) {
93617       {
93618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93619       };
93620     } catch (Dali::DaliException e) {
93621       {
93622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93623       };
93624     } catch (...) {
93625       {
93626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93627       };
93628     }
93629   }
93630
93631 }
93632
93633
93634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93635   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93636   int arg2 ;
93637   int arg3 ;
93638
93639   arg1 = (std::vector< unsigned int > *)jarg1;
93640   arg2 = (int)jarg2;
93641   arg3 = (int)jarg3;
93642   {
93643     try {
93644       try {
93645         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93646       }
93647       catch(std::out_of_range &_e) {
93648         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93649         return ;
93650       }
93651       catch(std::invalid_argument &_e) {
93652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93653         return ;
93654       }
93655
93656     } catch (std::out_of_range& e) {
93657       {
93658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93659       };
93660     } catch (std::exception& e) {
93661       {
93662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93663       };
93664     } catch (Dali::DaliException e) {
93665       {
93666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93667       };
93668     } catch (...) {
93669       {
93670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93671       };
93672     }
93673   }
93674
93675 }
93676
93677
93678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93679   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93680   int arg2 ;
93681   std::vector< unsigned int > *arg3 = 0 ;
93682
93683   arg1 = (std::vector< unsigned int > *)jarg1;
93684   arg2 = (int)jarg2;
93685   arg3 = (std::vector< unsigned int > *)jarg3;
93686   if (!arg3) {
93687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93688     return ;
93689   }
93690   {
93691     try {
93692       try {
93693         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93694       }
93695       catch(std::out_of_range &_e) {
93696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93697         return ;
93698       }
93699
93700     } catch (std::out_of_range& e) {
93701       {
93702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93703       };
93704     } catch (std::exception& e) {
93705       {
93706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93707       };
93708     } catch (Dali::DaliException e) {
93709       {
93710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93711       };
93712     } catch (...) {
93713       {
93714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93715       };
93716     }
93717   }
93718
93719 }
93720
93721
93722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93723   unsigned int jresult ;
93724   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93725   unsigned int *arg2 = 0 ;
93726   unsigned int temp2 ;
93727   bool result;
93728
93729   arg1 = (std::vector< unsigned int > *)jarg1;
93730   temp2 = (unsigned int)jarg2;
93731   arg2 = &temp2;
93732   {
93733     try {
93734       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93735     } catch (std::out_of_range& e) {
93736       {
93737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93738       };
93739     } catch (std::exception& e) {
93740       {
93741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93742       };
93743     } catch (Dali::DaliException e) {
93744       {
93745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93746       };
93747     } catch (...) {
93748       {
93749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93750       };
93751     }
93752   }
93753
93754   jresult = result;
93755   return jresult;
93756 }
93757
93758
93759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93760   int jresult ;
93761   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93762   unsigned int *arg2 = 0 ;
93763   unsigned int temp2 ;
93764   int result;
93765
93766   arg1 = (std::vector< unsigned int > *)jarg1;
93767   temp2 = (unsigned int)jarg2;
93768   arg2 = &temp2;
93769   {
93770     try {
93771       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93772     } catch (std::out_of_range& e) {
93773       {
93774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93775       };
93776     } catch (std::exception& e) {
93777       {
93778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93779       };
93780     } catch (Dali::DaliException e) {
93781       {
93782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93783       };
93784     } catch (...) {
93785       {
93786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93787       };
93788     }
93789   }
93790
93791   jresult = result;
93792   return jresult;
93793 }
93794
93795
93796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93797   int jresult ;
93798   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93799   unsigned int *arg2 = 0 ;
93800   unsigned int temp2 ;
93801   int result;
93802
93803   arg1 = (std::vector< unsigned int > *)jarg1;
93804   temp2 = (unsigned int)jarg2;
93805   arg2 = &temp2;
93806   {
93807     try {
93808       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93809     } catch (std::out_of_range& e) {
93810       {
93811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93812       };
93813     } catch (std::exception& e) {
93814       {
93815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93816       };
93817     } catch (Dali::DaliException e) {
93818       {
93819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93820       };
93821     } catch (...) {
93822       {
93823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93824       };
93825     }
93826   }
93827
93828   jresult = result;
93829   return jresult;
93830 }
93831
93832
93833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93834   unsigned int jresult ;
93835   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93836   unsigned int *arg2 = 0 ;
93837   unsigned int temp2 ;
93838   bool result;
93839
93840   arg1 = (std::vector< unsigned int > *)jarg1;
93841   temp2 = (unsigned int)jarg2;
93842   arg2 = &temp2;
93843   {
93844     try {
93845       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93846     } catch (std::out_of_range& e) {
93847       {
93848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93849       };
93850     } catch (std::exception& e) {
93851       {
93852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93853       };
93854     } catch (Dali::DaliException e) {
93855       {
93856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93857       };
93858     } catch (...) {
93859       {
93860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93861       };
93862     }
93863   }
93864
93865   jresult = result;
93866   return jresult;
93867 }
93868
93869
93870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93871   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93872
93873   arg1 = (std::vector< unsigned int > *)jarg1;
93874   {
93875     try {
93876       delete arg1;
93877     } catch (std::out_of_range& e) {
93878       {
93879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93880       };
93881     } catch (std::exception& e) {
93882       {
93883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93884       };
93885     } catch (Dali::DaliException e) {
93886       {
93887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93888       };
93889     } catch (...) {
93890       {
93891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93892       };
93893     }
93894   }
93895
93896 }
93897
93898
93899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93900   void * jresult ;
93901   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93902
93903   {
93904     try {
93905       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93906     } catch (std::out_of_range& e) {
93907       {
93908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93909       };
93910     } catch (std::exception& e) {
93911       {
93912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93913       };
93914     } catch (Dali::DaliException e) {
93915       {
93916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93917       };
93918     } catch (...) {
93919       {
93920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93921       };
93922     }
93923   }
93924
93925   jresult = (void *)result;
93926   return jresult;
93927 }
93928
93929
93930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93931   void * jresult ;
93932   unsigned int arg1 ;
93933   Dali::Actor arg2 ;
93934   Dali::Actor *argp2 ;
93935   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93936
93937   arg1 = (unsigned int)jarg1;
93938   argp2 = (Dali::Actor *)jarg2;
93939   if (!argp2) {
93940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93941     return 0;
93942   }
93943   arg2 = *argp2;
93944   {
93945     try {
93946       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93947     } catch (std::out_of_range& e) {
93948       {
93949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93950       };
93951     } catch (std::exception& e) {
93952       {
93953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93954       };
93955     } catch (Dali::DaliException e) {
93956       {
93957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93958       };
93959     } catch (...) {
93960       {
93961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93962       };
93963     }
93964   }
93965
93966   jresult = (void *)result;
93967   return jresult;
93968 }
93969
93970
93971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93972   void * jresult ;
93973   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93974   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93975
93976   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93977   if (!arg1) {
93978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93979     return 0;
93980   }
93981   {
93982     try {
93983       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93984     } catch (std::out_of_range& e) {
93985       {
93986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93987       };
93988     } catch (std::exception& e) {
93989       {
93990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93991       };
93992     } catch (Dali::DaliException e) {
93993       {
93994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93995       };
93996     } catch (...) {
93997       {
93998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93999       };
94000     }
94001   }
94002
94003   jresult = (void *)result;
94004   return jresult;
94005 }
94006
94007
94008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
94009   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94010   unsigned int arg2 ;
94011
94012   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94013   arg2 = (unsigned int)jarg2;
94014   if (arg1) (arg1)->first = arg2;
94015 }
94016
94017
94018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
94019   unsigned int jresult ;
94020   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94021   unsigned int result;
94022
94023   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94024   result = (unsigned int) ((arg1)->first);
94025   jresult = result;
94026   return jresult;
94027 }
94028
94029
94030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
94031   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94032   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
94033
94034   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94035   arg2 = (Dali::Actor *)jarg2;
94036   if (arg1) (arg1)->second = *arg2;
94037 }
94038
94039
94040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
94041   void * jresult ;
94042   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94043   Dali::Actor *result = 0 ;
94044
94045   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94046   result = (Dali::Actor *)& ((arg1)->second);
94047   jresult = (void *)result;
94048   return jresult;
94049 }
94050
94051
94052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
94053   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94054
94055   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94056   {
94057     try {
94058       delete arg1;
94059     } catch (std::out_of_range& e) {
94060       {
94061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94062       };
94063     } catch (std::exception& e) {
94064       {
94065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94066       };
94067     } catch (Dali::DaliException e) {
94068       {
94069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94070       };
94071     } catch (...) {
94072       {
94073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94074       };
94075     }
94076   }
94077
94078 }
94079
94080
94081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94082   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94083
94084   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94085   {
94086     try {
94087       (arg1)->clear();
94088     } catch (std::out_of_range& e) {
94089       {
94090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94091       };
94092     } catch (std::exception& e) {
94093       {
94094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94095       };
94096     } catch (Dali::DaliException e) {
94097       {
94098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94099       };
94100     } catch (...) {
94101       {
94102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94103       };
94104     }
94105   }
94106
94107 }
94108
94109
94110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94111   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94112   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94113
94114   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94115   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94116   if (!arg2) {
94117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94118     return ;
94119   }
94120   {
94121     try {
94122       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94123     } catch (std::out_of_range& e) {
94124       {
94125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94126       };
94127     } catch (std::exception& e) {
94128       {
94129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94130       };
94131     } catch (Dali::DaliException e) {
94132       {
94133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94134       };
94135     } catch (...) {
94136       {
94137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94138       };
94139     }
94140   }
94141
94142 }
94143
94144
94145 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94146   unsigned long jresult ;
94147   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94148   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94149
94150   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94151   {
94152     try {
94153       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94154     } catch (std::out_of_range& e) {
94155       {
94156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94157       };
94158     } catch (std::exception& e) {
94159       {
94160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94161       };
94162     } catch (Dali::DaliException e) {
94163       {
94164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94165       };
94166     } catch (...) {
94167       {
94168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94169       };
94170     }
94171   }
94172
94173   jresult = (unsigned long)result;
94174   return jresult;
94175 }
94176
94177
94178 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94179   unsigned long jresult ;
94180   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94181   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94182
94183   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94184   {
94185     try {
94186       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
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 = (unsigned long)result;
94207   return jresult;
94208 }
94209
94210
94211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94212   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94213   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94214
94215   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94216   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94217   {
94218     try {
94219       (arg1)->reserve(arg2);
94220     } catch (std::out_of_range& e) {
94221       {
94222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94223       };
94224     } catch (std::exception& e) {
94225       {
94226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94227       };
94228     } catch (Dali::DaliException e) {
94229       {
94230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94231       };
94232     } catch (...) {
94233       {
94234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94235       };
94236     }
94237   }
94238
94239 }
94240
94241
94242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94243   void * jresult ;
94244   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94245
94246   {
94247     try {
94248       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94249     } catch (std::out_of_range& e) {
94250       {
94251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94252       };
94253     } catch (std::exception& e) {
94254       {
94255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94256       };
94257     } catch (Dali::DaliException e) {
94258       {
94259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94260       };
94261     } catch (...) {
94262       {
94263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94264       };
94265     }
94266   }
94267
94268   jresult = (void *)result;
94269   return jresult;
94270 }
94271
94272
94273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94274   void * jresult ;
94275   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94276   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94277
94278   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94279   if (!arg1) {
94280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94281     return 0;
94282   }
94283   {
94284     try {
94285       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);
94286     } catch (std::out_of_range& e) {
94287       {
94288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94289       };
94290     } catch (std::exception& e) {
94291       {
94292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94293       };
94294     } catch (Dali::DaliException e) {
94295       {
94296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94297       };
94298     } catch (...) {
94299       {
94300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94301       };
94302     }
94303   }
94304
94305   jresult = (void *)result;
94306   return jresult;
94307 }
94308
94309
94310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94311   void * jresult ;
94312   int arg1 ;
94313   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94314
94315   arg1 = (int)jarg1;
94316   {
94317     try {
94318       try {
94319         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);
94320       }
94321       catch(std::out_of_range &_e) {
94322         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94323         return 0;
94324       }
94325
94326     } catch (std::out_of_range& e) {
94327       {
94328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94329       };
94330     } catch (std::exception& e) {
94331       {
94332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94333       };
94334     } catch (Dali::DaliException e) {
94335       {
94336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94337       };
94338     } catch (...) {
94339       {
94340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94341       };
94342     }
94343   }
94344
94345   jresult = (void *)result;
94346   return jresult;
94347 }
94348
94349
94350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94351   void * jresult ;
94352   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94353   int arg2 ;
94354   std::pair< unsigned int,Dali::Actor > result;
94355
94356   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94357   arg2 = (int)jarg2;
94358   {
94359     try {
94360       try {
94361         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94362       }
94363       catch(std::out_of_range &_e) {
94364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94365         return 0;
94366       }
94367
94368     } catch (std::out_of_range& e) {
94369       {
94370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94371       };
94372     } catch (std::exception& e) {
94373       {
94374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94375       };
94376     } catch (Dali::DaliException e) {
94377       {
94378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94379       };
94380     } catch (...) {
94381       {
94382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94383       };
94384     }
94385   }
94386
94387   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94388   return jresult;
94389 }
94390
94391
94392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94393   void * jresult ;
94394   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94395   int arg2 ;
94396   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94397
94398   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94399   arg2 = (int)jarg2;
94400   {
94401     try {
94402       try {
94403         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94404       }
94405       catch(std::out_of_range &_e) {
94406         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94407         return 0;
94408       }
94409
94410     } catch (std::out_of_range& e) {
94411       {
94412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94413       };
94414     } catch (std::exception& e) {
94415       {
94416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94417       };
94418     } catch (Dali::DaliException e) {
94419       {
94420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94421       };
94422     } catch (...) {
94423       {
94424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94425       };
94426     }
94427   }
94428
94429   jresult = (void *)result;
94430   return jresult;
94431 }
94432
94433
94434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94435   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94436   int arg2 ;
94437   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94438
94439   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94440   arg2 = (int)jarg2;
94441   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94442   if (!arg3) {
94443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94444     return ;
94445   }
94446   {
94447     try {
94448       try {
94449         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);
94450       }
94451       catch(std::out_of_range &_e) {
94452         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94453         return ;
94454       }
94455
94456     } catch (std::out_of_range& e) {
94457       {
94458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94459       };
94460     } catch (std::exception& e) {
94461       {
94462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94463       };
94464     } catch (Dali::DaliException e) {
94465       {
94466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94467       };
94468     } catch (...) {
94469       {
94470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94471       };
94472     }
94473   }
94474
94475 }
94476
94477
94478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94479   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94480   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94481
94482   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94483   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94484   if (!arg2) {
94485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94486     return ;
94487   }
94488   {
94489     try {
94490       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);
94491     } catch (std::out_of_range& e) {
94492       {
94493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94494       };
94495     } catch (std::exception& e) {
94496       {
94497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94498       };
94499     } catch (Dali::DaliException e) {
94500       {
94501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94502       };
94503     } catch (...) {
94504       {
94505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94506       };
94507     }
94508   }
94509
94510 }
94511
94512
94513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94514   void * jresult ;
94515   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94516   int arg2 ;
94517   int arg3 ;
94518   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94519
94520   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94521   arg2 = (int)jarg2;
94522   arg3 = (int)jarg3;
94523   {
94524     try {
94525       try {
94526         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);
94527       }
94528       catch(std::out_of_range &_e) {
94529         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94530         return 0;
94531       }
94532       catch(std::invalid_argument &_e) {
94533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94534         return 0;
94535       }
94536
94537     } catch (std::out_of_range& e) {
94538       {
94539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94540       };
94541     } catch (std::exception& e) {
94542       {
94543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94544       };
94545     } catch (Dali::DaliException e) {
94546       {
94547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94548       };
94549     } catch (...) {
94550       {
94551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94552       };
94553     }
94554   }
94555
94556   jresult = (void *)result;
94557   return jresult;
94558 }
94559
94560
94561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94562   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94563   int arg2 ;
94564   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94565
94566   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94567   arg2 = (int)jarg2;
94568   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94569   if (!arg3) {
94570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94571     return ;
94572   }
94573   {
94574     try {
94575       try {
94576         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);
94577       }
94578       catch(std::out_of_range &_e) {
94579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94580         return ;
94581       }
94582
94583     } catch (std::out_of_range& e) {
94584       {
94585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94586       };
94587     } catch (std::exception& e) {
94588       {
94589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94590       };
94591     } catch (Dali::DaliException e) {
94592       {
94593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94594       };
94595     } catch (...) {
94596       {
94597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94598       };
94599     }
94600   }
94601
94602 }
94603
94604
94605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94606   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94607   int arg2 ;
94608   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94609
94610   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94611   arg2 = (int)jarg2;
94612   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94613   if (!arg3) {
94614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94615     return ;
94616   }
94617   {
94618     try {
94619       try {
94620         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);
94621       }
94622       catch(std::out_of_range &_e) {
94623         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94624         return ;
94625       }
94626
94627     } catch (std::out_of_range& e) {
94628       {
94629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94630       };
94631     } catch (std::exception& e) {
94632       {
94633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94634       };
94635     } catch (Dali::DaliException e) {
94636       {
94637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94638       };
94639     } catch (...) {
94640       {
94641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94642       };
94643     }
94644   }
94645
94646 }
94647
94648
94649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94650   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94651   int arg2 ;
94652
94653   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94654   arg2 = (int)jarg2;
94655   {
94656     try {
94657       try {
94658         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94659       }
94660       catch(std::out_of_range &_e) {
94661         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94662         return ;
94663       }
94664
94665     } catch (std::out_of_range& e) {
94666       {
94667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94668       };
94669     } catch (std::exception& e) {
94670       {
94671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94672       };
94673     } catch (Dali::DaliException e) {
94674       {
94675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94676       };
94677     } catch (...) {
94678       {
94679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94680       };
94681     }
94682   }
94683
94684 }
94685
94686
94687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94688   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94689   int arg2 ;
94690   int arg3 ;
94691
94692   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94693   arg2 = (int)jarg2;
94694   arg3 = (int)jarg3;
94695   {
94696     try {
94697       try {
94698         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94699       }
94700       catch(std::out_of_range &_e) {
94701         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94702         return ;
94703       }
94704       catch(std::invalid_argument &_e) {
94705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94706         return ;
94707       }
94708
94709     } catch (std::out_of_range& e) {
94710       {
94711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94712       };
94713     } catch (std::exception& e) {
94714       {
94715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94716       };
94717     } catch (Dali::DaliException e) {
94718       {
94719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94720       };
94721     } catch (...) {
94722       {
94723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94724       };
94725     }
94726   }
94727
94728 }
94729
94730
94731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94732   void * jresult ;
94733   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94734   int arg2 ;
94735   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94736
94737   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94738   if (!arg1) {
94739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94740     return 0;
94741   }
94742   arg2 = (int)jarg2;
94743   {
94744     try {
94745       try {
94746         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);
94747       }
94748       catch(std::out_of_range &_e) {
94749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94750         return 0;
94751       }
94752
94753     } catch (std::out_of_range& e) {
94754       {
94755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94756       };
94757     } catch (std::exception& e) {
94758       {
94759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94760       };
94761     } catch (Dali::DaliException e) {
94762       {
94763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94764       };
94765     } catch (...) {
94766       {
94767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94768       };
94769     }
94770   }
94771
94772   jresult = (void *)result;
94773   return jresult;
94774 }
94775
94776
94777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94778   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94779
94780   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94781   {
94782     try {
94783       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94784     } catch (std::out_of_range& e) {
94785       {
94786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94787       };
94788     } catch (std::exception& e) {
94789       {
94790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94791       };
94792     } catch (Dali::DaliException e) {
94793       {
94794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94795       };
94796     } catch (...) {
94797       {
94798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94799       };
94800     }
94801   }
94802
94803 }
94804
94805
94806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94807   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94808   int arg2 ;
94809   int arg3 ;
94810
94811   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94812   arg2 = (int)jarg2;
94813   arg3 = (int)jarg3;
94814   {
94815     try {
94816       try {
94817         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94818       }
94819       catch(std::out_of_range &_e) {
94820         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94821         return ;
94822       }
94823       catch(std::invalid_argument &_e) {
94824         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94825         return ;
94826       }
94827
94828     } catch (std::out_of_range& e) {
94829       {
94830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94831       };
94832     } catch (std::exception& e) {
94833       {
94834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94835       };
94836     } catch (Dali::DaliException e) {
94837       {
94838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94839       };
94840     } catch (...) {
94841       {
94842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94843       };
94844     }
94845   }
94846
94847 }
94848
94849
94850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94851   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94852   int arg2 ;
94853   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94854
94855   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94856   arg2 = (int)jarg2;
94857   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94858   if (!arg3) {
94859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94860     return ;
94861   }
94862   {
94863     try {
94864       try {
94865         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);
94866       }
94867       catch(std::out_of_range &_e) {
94868         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94869         return ;
94870       }
94871
94872     } catch (std::out_of_range& e) {
94873       {
94874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94875       };
94876     } catch (std::exception& e) {
94877       {
94878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94879       };
94880     } catch (Dali::DaliException e) {
94881       {
94882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94883       };
94884     } catch (...) {
94885       {
94886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94887       };
94888     }
94889   }
94890
94891 }
94892
94893
94894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94895   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94896
94897   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94898   {
94899     try {
94900       delete arg1;
94901     } catch (std::out_of_range& e) {
94902       {
94903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94904       };
94905     } catch (std::exception& e) {
94906       {
94907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94908       };
94909     } catch (Dali::DaliException e) {
94910       {
94911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94912       };
94913     } catch (...) {
94914       {
94915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94916       };
94917     }
94918   }
94919
94920 }
94921
94922
94923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94924   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94925
94926   arg1 = (std::vector< Dali::Actor > *)jarg1;
94927   {
94928     try {
94929       (arg1)->clear();
94930     } catch (std::out_of_range& e) {
94931       {
94932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94933       };
94934     } catch (std::exception& e) {
94935       {
94936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94937       };
94938     } catch (Dali::DaliException e) {
94939       {
94940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94941       };
94942     } catch (...) {
94943       {
94944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94945       };
94946     }
94947   }
94948
94949 }
94950
94951
94952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94953   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94954   Dali::Actor *arg2 = 0 ;
94955
94956   arg1 = (std::vector< Dali::Actor > *)jarg1;
94957   arg2 = (Dali::Actor *)jarg2;
94958   if (!arg2) {
94959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94960     return ;
94961   }
94962   {
94963     try {
94964       (arg1)->push_back((Dali::Actor const &)*arg2);
94965     } catch (std::out_of_range& e) {
94966       {
94967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94968       };
94969     } catch (std::exception& e) {
94970       {
94971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94972       };
94973     } catch (Dali::DaliException e) {
94974       {
94975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94976       };
94977     } catch (...) {
94978       {
94979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94980       };
94981     }
94982   }
94983
94984 }
94985
94986
94987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94988   unsigned long jresult ;
94989   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94990   std::vector< Dali::Actor >::size_type result;
94991
94992   arg1 = (std::vector< Dali::Actor > *)jarg1;
94993   {
94994     try {
94995       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94996     } catch (std::out_of_range& e) {
94997       {
94998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94999       };
95000     } catch (std::exception& e) {
95001       {
95002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95003       };
95004     } catch (Dali::DaliException e) {
95005       {
95006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95007       };
95008     } catch (...) {
95009       {
95010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95011       };
95012     }
95013   }
95014
95015   jresult = (unsigned long)result;
95016   return jresult;
95017 }
95018
95019
95020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
95021   unsigned long jresult ;
95022   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95023   std::vector< Dali::Actor >::size_type result;
95024
95025   arg1 = (std::vector< Dali::Actor > *)jarg1;
95026   {
95027     try {
95028       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
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 = (unsigned long)result;
95049   return jresult;
95050 }
95051
95052
95053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
95054   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95055   std::vector< Dali::Actor >::size_type arg2 ;
95056
95057   arg1 = (std::vector< Dali::Actor > *)jarg1;
95058   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
95059   {
95060     try {
95061       (arg1)->reserve(arg2);
95062     } catch (std::out_of_range& e) {
95063       {
95064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95065       };
95066     } catch (std::exception& e) {
95067       {
95068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95069       };
95070     } catch (Dali::DaliException e) {
95071       {
95072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95073       };
95074     } catch (...) {
95075       {
95076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95077       };
95078     }
95079   }
95080
95081 }
95082
95083
95084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95085   void * jresult ;
95086   std::vector< Dali::Actor > *result = 0 ;
95087
95088   {
95089     try {
95090       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95091     } catch (std::out_of_range& e) {
95092       {
95093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95094       };
95095     } catch (std::exception& e) {
95096       {
95097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95098       };
95099     } catch (Dali::DaliException e) {
95100       {
95101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95102       };
95103     } catch (...) {
95104       {
95105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95106       };
95107     }
95108   }
95109
95110   jresult = (void *)result;
95111   return jresult;
95112 }
95113
95114
95115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95116   void * jresult ;
95117   std::vector< Dali::Actor > *arg1 = 0 ;
95118   std::vector< Dali::Actor > *result = 0 ;
95119
95120   arg1 = (std::vector< Dali::Actor > *)jarg1;
95121   if (!arg1) {
95122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95123     return 0;
95124   }
95125   {
95126     try {
95127       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95128     } catch (std::out_of_range& e) {
95129       {
95130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95131       };
95132     } catch (std::exception& e) {
95133       {
95134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95135       };
95136     } catch (Dali::DaliException e) {
95137       {
95138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95139       };
95140     } catch (...) {
95141       {
95142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95143       };
95144     }
95145   }
95146
95147   jresult = (void *)result;
95148   return jresult;
95149 }
95150
95151
95152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95153   void * jresult ;
95154   int arg1 ;
95155   std::vector< Dali::Actor > *result = 0 ;
95156
95157   arg1 = (int)jarg1;
95158   {
95159     try {
95160       try {
95161         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95162       }
95163       catch(std::out_of_range &_e) {
95164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95165         return 0;
95166       }
95167
95168     } catch (std::out_of_range& e) {
95169       {
95170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95171       };
95172     } catch (std::exception& e) {
95173       {
95174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95175       };
95176     } catch (Dali::DaliException e) {
95177       {
95178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95179       };
95180     } catch (...) {
95181       {
95182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95183       };
95184     }
95185   }
95186
95187   jresult = (void *)result;
95188   return jresult;
95189 }
95190
95191
95192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95193   void * jresult ;
95194   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95195   int arg2 ;
95196   Dali::Actor result;
95197
95198   arg1 = (std::vector< Dali::Actor > *)jarg1;
95199   arg2 = (int)jarg2;
95200   {
95201     try {
95202       try {
95203         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95204       }
95205       catch(std::out_of_range &_e) {
95206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95207         return 0;
95208       }
95209
95210     } catch (std::out_of_range& e) {
95211       {
95212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95213       };
95214     } catch (std::exception& e) {
95215       {
95216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95217       };
95218     } catch (Dali::DaliException e) {
95219       {
95220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95221       };
95222     } catch (...) {
95223       {
95224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95225       };
95226     }
95227   }
95228
95229   jresult = new Dali::Actor((const Dali::Actor &)result);
95230   return jresult;
95231 }
95232
95233
95234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95235   void * jresult ;
95236   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95237   int arg2 ;
95238   Dali::Actor *result = 0 ;
95239
95240   arg1 = (std::vector< Dali::Actor > *)jarg1;
95241   arg2 = (int)jarg2;
95242   {
95243     try {
95244       try {
95245         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95246       }
95247       catch(std::out_of_range &_e) {
95248         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95249         return 0;
95250       }
95251
95252     } catch (std::out_of_range& e) {
95253       {
95254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95255       };
95256     } catch (std::exception& e) {
95257       {
95258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95259       };
95260     } catch (Dali::DaliException e) {
95261       {
95262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95263       };
95264     } catch (...) {
95265       {
95266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95267       };
95268     }
95269   }
95270
95271   jresult = (void *)result;
95272   return jresult;
95273 }
95274
95275
95276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95277   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95278   int arg2 ;
95279   Dali::Actor *arg3 = 0 ;
95280
95281   arg1 = (std::vector< Dali::Actor > *)jarg1;
95282   arg2 = (int)jarg2;
95283   arg3 = (Dali::Actor *)jarg3;
95284   if (!arg3) {
95285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95286     return ;
95287   }
95288   {
95289     try {
95290       try {
95291         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95292       }
95293       catch(std::out_of_range &_e) {
95294         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95295         return ;
95296       }
95297
95298     } catch (std::out_of_range& e) {
95299       {
95300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95301       };
95302     } catch (std::exception& e) {
95303       {
95304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95305       };
95306     } catch (Dali::DaliException e) {
95307       {
95308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95309       };
95310     } catch (...) {
95311       {
95312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95313       };
95314     }
95315   }
95316
95317 }
95318
95319
95320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95321   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95322   std::vector< Dali::Actor > *arg2 = 0 ;
95323
95324   arg1 = (std::vector< Dali::Actor > *)jarg1;
95325   arg2 = (std::vector< Dali::Actor > *)jarg2;
95326   if (!arg2) {
95327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95328     return ;
95329   }
95330   {
95331     try {
95332       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95333     } catch (std::out_of_range& e) {
95334       {
95335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95336       };
95337     } catch (std::exception& e) {
95338       {
95339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95340       };
95341     } catch (Dali::DaliException e) {
95342       {
95343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95344       };
95345     } catch (...) {
95346       {
95347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95348       };
95349     }
95350   }
95351
95352 }
95353
95354
95355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95356   void * jresult ;
95357   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95358   int arg2 ;
95359   int arg3 ;
95360   std::vector< Dali::Actor > *result = 0 ;
95361
95362   arg1 = (std::vector< Dali::Actor > *)jarg1;
95363   arg2 = (int)jarg2;
95364   arg3 = (int)jarg3;
95365   {
95366     try {
95367       try {
95368         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95369       }
95370       catch(std::out_of_range &_e) {
95371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95372         return 0;
95373       }
95374       catch(std::invalid_argument &_e) {
95375         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95376         return 0;
95377       }
95378
95379     } catch (std::out_of_range& e) {
95380       {
95381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95382       };
95383     } catch (std::exception& e) {
95384       {
95385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95386       };
95387     } catch (Dali::DaliException e) {
95388       {
95389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95390       };
95391     } catch (...) {
95392       {
95393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95394       };
95395     }
95396   }
95397
95398   jresult = (void *)result;
95399   return jresult;
95400 }
95401
95402
95403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95404   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95405   int arg2 ;
95406   Dali::Actor *arg3 = 0 ;
95407
95408   arg1 = (std::vector< Dali::Actor > *)jarg1;
95409   arg2 = (int)jarg2;
95410   arg3 = (Dali::Actor *)jarg3;
95411   if (!arg3) {
95412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95413     return ;
95414   }
95415   {
95416     try {
95417       try {
95418         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95419       }
95420       catch(std::out_of_range &_e) {
95421         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95422         return ;
95423       }
95424
95425     } catch (std::out_of_range& e) {
95426       {
95427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95428       };
95429     } catch (std::exception& e) {
95430       {
95431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95432       };
95433     } catch (Dali::DaliException e) {
95434       {
95435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95436       };
95437     } catch (...) {
95438       {
95439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95440       };
95441     }
95442   }
95443
95444 }
95445
95446
95447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95448   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95449   int arg2 ;
95450   std::vector< Dali::Actor > *arg3 = 0 ;
95451
95452   arg1 = (std::vector< Dali::Actor > *)jarg1;
95453   arg2 = (int)jarg2;
95454   arg3 = (std::vector< Dali::Actor > *)jarg3;
95455   if (!arg3) {
95456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95457     return ;
95458   }
95459   {
95460     try {
95461       try {
95462         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95463       }
95464       catch(std::out_of_range &_e) {
95465         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95466         return ;
95467       }
95468
95469     } catch (std::out_of_range& e) {
95470       {
95471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95472       };
95473     } catch (std::exception& e) {
95474       {
95475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95476       };
95477     } catch (Dali::DaliException e) {
95478       {
95479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95480       };
95481     } catch (...) {
95482       {
95483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95484       };
95485     }
95486   }
95487
95488 }
95489
95490
95491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95492   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95493   int arg2 ;
95494
95495   arg1 = (std::vector< Dali::Actor > *)jarg1;
95496   arg2 = (int)jarg2;
95497   {
95498     try {
95499       try {
95500         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95501       }
95502       catch(std::out_of_range &_e) {
95503         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95504         return ;
95505       }
95506
95507     } catch (std::out_of_range& e) {
95508       {
95509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95510       };
95511     } catch (std::exception& e) {
95512       {
95513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95514       };
95515     } catch (Dali::DaliException e) {
95516       {
95517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95518       };
95519     } catch (...) {
95520       {
95521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95522       };
95523     }
95524   }
95525
95526 }
95527
95528
95529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95530   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95531   int arg2 ;
95532   int arg3 ;
95533
95534   arg1 = (std::vector< Dali::Actor > *)jarg1;
95535   arg2 = (int)jarg2;
95536   arg3 = (int)jarg3;
95537   {
95538     try {
95539       try {
95540         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95541       }
95542       catch(std::out_of_range &_e) {
95543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95544         return ;
95545       }
95546       catch(std::invalid_argument &_e) {
95547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95548         return ;
95549       }
95550
95551     } catch (std::out_of_range& e) {
95552       {
95553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95554       };
95555     } catch (std::exception& e) {
95556       {
95557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95558       };
95559     } catch (Dali::DaliException e) {
95560       {
95561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95562       };
95563     } catch (...) {
95564       {
95565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95566       };
95567     }
95568   }
95569
95570 }
95571
95572
95573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95574   void * jresult ;
95575   Dali::Actor *arg1 = 0 ;
95576   int arg2 ;
95577   std::vector< Dali::Actor > *result = 0 ;
95578
95579   arg1 = (Dali::Actor *)jarg1;
95580   if (!arg1) {
95581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95582     return 0;
95583   }
95584   arg2 = (int)jarg2;
95585   {
95586     try {
95587       try {
95588         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95589       }
95590       catch(std::out_of_range &_e) {
95591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95592         return 0;
95593       }
95594
95595     } catch (std::out_of_range& e) {
95596       {
95597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95598       };
95599     } catch (std::exception& e) {
95600       {
95601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95602       };
95603     } catch (Dali::DaliException e) {
95604       {
95605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95606       };
95607     } catch (...) {
95608       {
95609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95610       };
95611     }
95612   }
95613
95614   jresult = (void *)result;
95615   return jresult;
95616 }
95617
95618
95619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95620   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95621
95622   arg1 = (std::vector< Dali::Actor > *)jarg1;
95623   {
95624     try {
95625       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95626     } catch (std::out_of_range& e) {
95627       {
95628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95629       };
95630     } catch (std::exception& e) {
95631       {
95632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95633       };
95634     } catch (Dali::DaliException e) {
95635       {
95636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95637       };
95638     } catch (...) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95641       };
95642     }
95643   }
95644
95645 }
95646
95647
95648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95649   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95650   int arg2 ;
95651   int arg3 ;
95652
95653   arg1 = (std::vector< Dali::Actor > *)jarg1;
95654   arg2 = (int)jarg2;
95655   arg3 = (int)jarg3;
95656   {
95657     try {
95658       try {
95659         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95660       }
95661       catch(std::out_of_range &_e) {
95662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95663         return ;
95664       }
95665       catch(std::invalid_argument &_e) {
95666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95667         return ;
95668       }
95669
95670     } catch (std::out_of_range& e) {
95671       {
95672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95673       };
95674     } catch (std::exception& e) {
95675       {
95676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95677       };
95678     } catch (Dali::DaliException e) {
95679       {
95680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95681       };
95682     } catch (...) {
95683       {
95684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95685       };
95686     }
95687   }
95688
95689 }
95690
95691
95692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95693   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95694   int arg2 ;
95695   std::vector< Dali::Actor > *arg3 = 0 ;
95696
95697   arg1 = (std::vector< Dali::Actor > *)jarg1;
95698   arg2 = (int)jarg2;
95699   arg3 = (std::vector< Dali::Actor > *)jarg3;
95700   if (!arg3) {
95701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95702     return ;
95703   }
95704   {
95705     try {
95706       try {
95707         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95708       }
95709       catch(std::out_of_range &_e) {
95710         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95711         return ;
95712       }
95713
95714     } catch (std::out_of_range& e) {
95715       {
95716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95717       };
95718     } catch (std::exception& e) {
95719       {
95720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95721       };
95722     } catch (Dali::DaliException e) {
95723       {
95724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95725       };
95726     } catch (...) {
95727       {
95728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95729       };
95730     }
95731   }
95732
95733 }
95734
95735
95736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95737   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95738
95739   arg1 = (std::vector< Dali::Actor > *)jarg1;
95740   {
95741     try {
95742       delete arg1;
95743     } catch (std::out_of_range& e) {
95744       {
95745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95746       };
95747     } catch (std::exception& e) {
95748       {
95749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95750       };
95751     } catch (Dali::DaliException e) {
95752       {
95753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95754       };
95755     } catch (...) {
95756       {
95757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95758       };
95759     }
95760   }
95761
95762 }
95763
95764
95765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95766   unsigned int jresult ;
95767   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95768   bool result;
95769
95770   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95771   {
95772     try {
95773       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95774     } catch (std::out_of_range& e) {
95775       {
95776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95777       };
95778     } catch (std::exception& e) {
95779       {
95780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95781       };
95782     } catch (Dali::DaliException e) {
95783       {
95784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95785       };
95786     } catch (...) {
95787       {
95788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95789       };
95790     }
95791   }
95792
95793   jresult = result;
95794   return jresult;
95795 }
95796
95797
95798 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95799   unsigned long jresult ;
95800   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95801   std::size_t result;
95802
95803   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95804   {
95805     try {
95806       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95807     } catch (std::out_of_range& e) {
95808       {
95809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95810       };
95811     } catch (std::exception& e) {
95812       {
95813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95814       };
95815     } catch (Dali::DaliException e) {
95816       {
95817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95818       };
95819     } catch (...) {
95820       {
95821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95822       };
95823     }
95824   }
95825
95826   jresult = (unsigned long)result;
95827   return jresult;
95828 }
95829
95830
95831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95832   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95833   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95834
95835   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95836   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95837   {
95838     try {
95839       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95840     } catch (std::out_of_range& e) {
95841       {
95842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95843       };
95844     } catch (std::exception& e) {
95845       {
95846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95847       };
95848     } catch (Dali::DaliException e) {
95849       {
95850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95851       };
95852     } catch (...) {
95853       {
95854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95855       };
95856     }
95857   }
95858
95859 }
95860
95861
95862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95863   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95864   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95865
95866   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95867   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95868   {
95869     try {
95870       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95871     } catch (std::out_of_range& e) {
95872       {
95873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95874       };
95875     } catch (std::exception& e) {
95876       {
95877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95878       };
95879     } catch (Dali::DaliException e) {
95880       {
95881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95882       };
95883     } catch (...) {
95884       {
95885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95886       };
95887     }
95888   }
95889
95890 }
95891
95892
95893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95894   unsigned int jresult ;
95895   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95896   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95897   bool result;
95898
95899   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95900   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95901   if (!arg2) {
95902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95903     return 0;
95904   }
95905   {
95906     try {
95907       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95908     } catch (std::out_of_range& e) {
95909       {
95910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95911       };
95912     } catch (std::exception& e) {
95913       {
95914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95915       };
95916     } catch (Dali::DaliException e) {
95917       {
95918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95919       };
95920     } catch (...) {
95921       {
95922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95923       };
95924     }
95925   }
95926
95927   jresult = result;
95928   return jresult;
95929 }
95930
95931
95932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95933   void * jresult ;
95934   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95935
95936   {
95937     try {
95938       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95939     } catch (std::out_of_range& e) {
95940       {
95941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95942       };
95943     } catch (std::exception& e) {
95944       {
95945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95946       };
95947     } catch (Dali::DaliException e) {
95948       {
95949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95950       };
95951     } catch (...) {
95952       {
95953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95954       };
95955     }
95956   }
95957
95958   jresult = (void *)result;
95959   return jresult;
95960 }
95961
95962
95963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95964   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95965
95966   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95967   {
95968     try {
95969       delete arg1;
95970     } catch (std::out_of_range& e) {
95971       {
95972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95973       };
95974     } catch (std::exception& e) {
95975       {
95976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95977       };
95978     } catch (Dali::DaliException e) {
95979       {
95980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95981       };
95982     } catch (...) {
95983       {
95984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95985       };
95986     }
95987   }
95988
95989 }
95990
95991
95992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95993   unsigned int jresult ;
95994   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95995   bool result;
95996
95997   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95998   {
95999     try {
96000       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);
96001     } catch (std::out_of_range& e) {
96002       {
96003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96004       };
96005     } catch (std::exception& e) {
96006       {
96007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96008       };
96009     } catch (Dali::DaliException e) {
96010       {
96011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96012       };
96013     } catch (...) {
96014       {
96015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96016       };
96017     }
96018   }
96019
96020   jresult = result;
96021   return jresult;
96022 }
96023
96024
96025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
96026   unsigned long jresult ;
96027   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96028   std::size_t result;
96029
96030   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96031   {
96032     try {
96033       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);
96034     } catch (std::out_of_range& e) {
96035       {
96036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96037       };
96038     } catch (std::exception& e) {
96039       {
96040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96041       };
96042     } catch (Dali::DaliException e) {
96043       {
96044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96045       };
96046     } catch (...) {
96047       {
96048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96049       };
96050     }
96051   }
96052
96053   jresult = (unsigned long)result;
96054   return jresult;
96055 }
96056
96057
96058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
96059   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96060   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96061
96062   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96063   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96064   {
96065     try {
96066       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
96067     } catch (std::out_of_range& e) {
96068       {
96069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96070       };
96071     } catch (std::exception& e) {
96072       {
96073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96074       };
96075     } catch (Dali::DaliException e) {
96076       {
96077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96078       };
96079     } catch (...) {
96080       {
96081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96082       };
96083     }
96084   }
96085
96086 }
96087
96088
96089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96090   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96091   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96092
96093   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96094   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96095   {
96096     try {
96097       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96098     } catch (std::out_of_range& e) {
96099       {
96100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96101       };
96102     } catch (std::exception& e) {
96103       {
96104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96105       };
96106     } catch (Dali::DaliException e) {
96107       {
96108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96109       };
96110     } catch (...) {
96111       {
96112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96113       };
96114     }
96115   }
96116
96117 }
96118
96119
96120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96121   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96122   Dali::Actor arg2 ;
96123   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96124   Dali::Actor *argp2 ;
96125
96126   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96127   argp2 = (Dali::Actor *)jarg2;
96128   if (!argp2) {
96129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96130     return ;
96131   }
96132   arg2 = *argp2;
96133   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96134   {
96135     try {
96136       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96137     } catch (std::out_of_range& e) {
96138       {
96139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96140       };
96141     } catch (std::exception& e) {
96142       {
96143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96144       };
96145     } catch (Dali::DaliException e) {
96146       {
96147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96148       };
96149     } catch (...) {
96150       {
96151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96152       };
96153     }
96154   }
96155
96156 }
96157
96158
96159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96160   void * jresult ;
96161   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96162
96163   {
96164     try {
96165       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96166     } catch (std::out_of_range& e) {
96167       {
96168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96169       };
96170     } catch (std::exception& e) {
96171       {
96172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96173       };
96174     } catch (Dali::DaliException e) {
96175       {
96176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96177       };
96178     } catch (...) {
96179       {
96180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96181       };
96182     }
96183   }
96184
96185   jresult = (void *)result;
96186   return jresult;
96187 }
96188
96189
96190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96191   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96192
96193   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96194   {
96195     try {
96196       delete arg1;
96197     } catch (std::out_of_range& e) {
96198       {
96199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96200       };
96201     } catch (std::exception& e) {
96202       {
96203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96204       };
96205     } catch (Dali::DaliException e) {
96206       {
96207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96208       };
96209     } catch (...) {
96210       {
96211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96212       };
96213     }
96214   }
96215
96216 }
96217
96218
96219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96220   unsigned int jresult ;
96221   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96222   bool result;
96223
96224   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96225   {
96226     try {
96227       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96228     } catch (std::out_of_range& e) {
96229       {
96230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96231       };
96232     } catch (std::exception& e) {
96233       {
96234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96235       };
96236     } catch (Dali::DaliException e) {
96237       {
96238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96239       };
96240     } catch (...) {
96241       {
96242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96243       };
96244     }
96245   }
96246
96247   jresult = result;
96248   return jresult;
96249 }
96250
96251
96252 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96253   unsigned long jresult ;
96254   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96255   std::size_t result;
96256
96257   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96258   {
96259     try {
96260       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96261     } catch (std::out_of_range& e) {
96262       {
96263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96264       };
96265     } catch (std::exception& e) {
96266       {
96267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96268       };
96269     } catch (Dali::DaliException e) {
96270       {
96271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96272       };
96273     } catch (...) {
96274       {
96275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96276       };
96277     }
96278   }
96279
96280   jresult = (unsigned long)result;
96281   return jresult;
96282 }
96283
96284
96285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96286   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96287   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96288
96289   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96290   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96291   {
96292     try {
96293       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96294     } catch (std::out_of_range& e) {
96295       {
96296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96297       };
96298     } catch (std::exception& e) {
96299       {
96300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96301       };
96302     } catch (Dali::DaliException e) {
96303       {
96304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96305       };
96306     } catch (...) {
96307       {
96308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96309       };
96310     }
96311   }
96312
96313 }
96314
96315
96316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96317   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96318   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96319
96320   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96321   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96322   {
96323     try {
96324       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96325     } catch (std::out_of_range& e) {
96326       {
96327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96328       };
96329     } catch (std::exception& e) {
96330       {
96331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96332       };
96333     } catch (Dali::DaliException e) {
96334       {
96335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96336       };
96337     } catch (...) {
96338       {
96339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96340       };
96341     }
96342   }
96343
96344 }
96345
96346
96347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96348   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96349   Dali::Actor arg2 ;
96350   Dali::Actor arg3 ;
96351   Dali::Actor *argp2 ;
96352   Dali::Actor *argp3 ;
96353
96354   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96355   argp2 = (Dali::Actor *)jarg2;
96356   if (!argp2) {
96357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96358     return ;
96359   }
96360   arg2 = *argp2;
96361   argp3 = (Dali::Actor *)jarg3;
96362   if (!argp3) {
96363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96364     return ;
96365   }
96366   arg3 = *argp3;
96367   {
96368     try {
96369       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96370     } catch (std::out_of_range& e) {
96371       {
96372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96373       };
96374     } catch (std::exception& e) {
96375       {
96376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96377       };
96378     } catch (Dali::DaliException e) {
96379       {
96380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96381       };
96382     } catch (...) {
96383       {
96384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96385       };
96386     }
96387   }
96388
96389 }
96390
96391
96392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96393   void * jresult ;
96394   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96395
96396   {
96397     try {
96398       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96399     } catch (std::out_of_range& e) {
96400       {
96401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96402       };
96403     } catch (std::exception& e) {
96404       {
96405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96406       };
96407     } catch (Dali::DaliException e) {
96408       {
96409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96410       };
96411     } catch (...) {
96412       {
96413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96414       };
96415     }
96416   }
96417
96418   jresult = (void *)result;
96419   return jresult;
96420 }
96421
96422
96423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96424   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96425
96426   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96427   {
96428     try {
96429       delete arg1;
96430     } catch (std::out_of_range& e) {
96431       {
96432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96433       };
96434     } catch (std::exception& e) {
96435       {
96436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96437       };
96438     } catch (Dali::DaliException e) {
96439       {
96440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96441       };
96442     } catch (...) {
96443       {
96444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96445       };
96446     }
96447   }
96448
96449 }
96450
96451
96452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96453   unsigned int jresult ;
96454   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96455   bool result;
96456
96457   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96458   {
96459     try {
96460       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96461     } catch (std::out_of_range& e) {
96462       {
96463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96464       };
96465     } catch (std::exception& e) {
96466       {
96467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96468       };
96469     } catch (Dali::DaliException e) {
96470       {
96471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96472       };
96473     } catch (...) {
96474       {
96475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96476       };
96477     }
96478   }
96479
96480   jresult = result;
96481   return jresult;
96482 }
96483
96484
96485 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96486   unsigned long jresult ;
96487   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96488   std::size_t result;
96489
96490   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96491   {
96492     try {
96493       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96494     } catch (std::out_of_range& e) {
96495       {
96496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96497       };
96498     } catch (std::exception& e) {
96499       {
96500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96501       };
96502     } catch (Dali::DaliException e) {
96503       {
96504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96505       };
96506     } catch (...) {
96507       {
96508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96509       };
96510     }
96511   }
96512
96513   jresult = (unsigned long)result;
96514   return jresult;
96515 }
96516
96517
96518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96519   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96520   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96521
96522   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96523   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96524   {
96525     try {
96526       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96527     } catch (std::out_of_range& e) {
96528       {
96529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96530       };
96531     } catch (std::exception& e) {
96532       {
96533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96534       };
96535     } catch (Dali::DaliException e) {
96536       {
96537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96538       };
96539     } catch (...) {
96540       {
96541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96542       };
96543     }
96544   }
96545
96546 }
96547
96548
96549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96550   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96551   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96552
96553   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96554   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96555   {
96556     try {
96557       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96558     } catch (std::out_of_range& e) {
96559       {
96560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96561       };
96562     } catch (std::exception& e) {
96563       {
96564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96565       };
96566     } catch (Dali::DaliException e) {
96567       {
96568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96569       };
96570     } catch (...) {
96571       {
96572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96573       };
96574     }
96575   }
96576
96577 }
96578
96579
96580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96581   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96582   Dali::Actor arg2 ;
96583   bool arg3 ;
96584   Dali::Actor *argp2 ;
96585
96586   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96587   argp2 = (Dali::Actor *)jarg2;
96588   if (!argp2) {
96589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96590     return ;
96591   }
96592   arg2 = *argp2;
96593   arg3 = jarg3 ? true : false;
96594   {
96595     try {
96596       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96597     } catch (std::out_of_range& e) {
96598       {
96599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96600       };
96601     } catch (std::exception& e) {
96602       {
96603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96604       };
96605     } catch (Dali::DaliException e) {
96606       {
96607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96608       };
96609     } catch (...) {
96610       {
96611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96612       };
96613     }
96614   }
96615
96616 }
96617
96618
96619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96620   void * jresult ;
96621   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96622
96623   {
96624     try {
96625       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96626     } catch (std::out_of_range& e) {
96627       {
96628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96629       };
96630     } catch (std::exception& e) {
96631       {
96632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96633       };
96634     } catch (Dali::DaliException e) {
96635       {
96636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96637       };
96638     } catch (...) {
96639       {
96640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96641       };
96642     }
96643   }
96644
96645   jresult = (void *)result;
96646   return jresult;
96647 }
96648
96649
96650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96651   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96652
96653   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96654   {
96655     try {
96656       delete arg1;
96657     } catch (std::out_of_range& e) {
96658       {
96659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96660       };
96661     } catch (std::exception& e) {
96662       {
96663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96664       };
96665     } catch (Dali::DaliException e) {
96666       {
96667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96668       };
96669     } catch (...) {
96670       {
96671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96672       };
96673     }
96674   }
96675
96676 }
96677
96678
96679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96680   unsigned int jresult ;
96681   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96682   bool result;
96683
96684   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96685   {
96686     try {
96687       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);
96688     } catch (std::out_of_range& e) {
96689       {
96690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96691       };
96692     } catch (std::exception& e) {
96693       {
96694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96695       };
96696     } catch (Dali::DaliException e) {
96697       {
96698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96699       };
96700     } catch (...) {
96701       {
96702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96703       };
96704     }
96705   }
96706
96707   jresult = result;
96708   return jresult;
96709 }
96710
96711
96712 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96713   unsigned long jresult ;
96714   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96715   std::size_t result;
96716
96717   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96718   {
96719     try {
96720       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);
96721     } catch (std::out_of_range& e) {
96722       {
96723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96724       };
96725     } catch (std::exception& e) {
96726       {
96727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96728       };
96729     } catch (Dali::DaliException e) {
96730       {
96731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96732       };
96733     } catch (...) {
96734       {
96735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96736       };
96737     }
96738   }
96739
96740   jresult = (unsigned long)result;
96741   return jresult;
96742 }
96743
96744
96745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96746   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96747   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96748
96749   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96750   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96751   {
96752     try {
96753       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96754     } catch (std::out_of_range& e) {
96755       {
96756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96757       };
96758     } catch (std::exception& e) {
96759       {
96760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96761       };
96762     } catch (Dali::DaliException e) {
96763       {
96764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96765       };
96766     } catch (...) {
96767       {
96768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96769       };
96770     }
96771   }
96772
96773 }
96774
96775
96776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96777   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96778   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96779
96780   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96781   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96782   {
96783     try {
96784       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96785     } catch (std::out_of_range& e) {
96786       {
96787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96788       };
96789     } catch (std::exception& e) {
96790       {
96791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96792       };
96793     } catch (Dali::DaliException e) {
96794       {
96795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96796       };
96797     } catch (...) {
96798       {
96799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96800       };
96801     }
96802   }
96803
96804 }
96805
96806
96807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96808   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96809   Dali::Toolkit::StyleManager arg2 ;
96810   Dali::StyleChange::Type arg3 ;
96811   Dali::Toolkit::StyleManager *argp2 ;
96812
96813   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96814   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96815   if (!argp2) {
96816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96817     return ;
96818   }
96819   arg2 = *argp2;
96820   arg3 = (Dali::StyleChange::Type)jarg3;
96821   {
96822     try {
96823       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96824     } catch (std::out_of_range& e) {
96825       {
96826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96827       };
96828     } catch (std::exception& e) {
96829       {
96830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96831       };
96832     } catch (Dali::DaliException e) {
96833       {
96834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96835       };
96836     } catch (...) {
96837       {
96838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96839       };
96840     }
96841   }
96842
96843 }
96844
96845
96846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96847   void * jresult ;
96848   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96849
96850   {
96851     try {
96852       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96853     } catch (std::out_of_range& e) {
96854       {
96855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96856       };
96857     } catch (std::exception& e) {
96858       {
96859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96860       };
96861     } catch (Dali::DaliException e) {
96862       {
96863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96864       };
96865     } catch (...) {
96866       {
96867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96868       };
96869     }
96870   }
96871
96872   jresult = (void *)result;
96873   return jresult;
96874 }
96875
96876
96877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96878   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96879
96880   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96881   {
96882     try {
96883       delete arg1;
96884     } catch (std::out_of_range& e) {
96885       {
96886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96887       };
96888     } catch (std::exception& e) {
96889       {
96890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96891       };
96892     } catch (Dali::DaliException e) {
96893       {
96894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96895       };
96896     } catch (...) {
96897       {
96898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96899       };
96900     }
96901   }
96902
96903 }
96904
96905
96906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96907   unsigned int jresult ;
96908   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96909   bool result;
96910
96911   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96912   {
96913     try {
96914       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96915     } catch (std::out_of_range& e) {
96916       {
96917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96918       };
96919     } catch (std::exception& e) {
96920       {
96921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96922       };
96923     } catch (Dali::DaliException e) {
96924       {
96925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96926       };
96927     } catch (...) {
96928       {
96929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96930       };
96931     }
96932   }
96933
96934   jresult = result;
96935   return jresult;
96936 }
96937
96938
96939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96940   unsigned long jresult ;
96941   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96942   std::size_t result;
96943
96944   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96945   {
96946     try {
96947       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96948     } catch (std::out_of_range& e) {
96949       {
96950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96951       };
96952     } catch (std::exception& e) {
96953       {
96954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96955       };
96956     } catch (Dali::DaliException e) {
96957       {
96958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96959       };
96960     } catch (...) {
96961       {
96962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96963       };
96964     }
96965   }
96966
96967   jresult = (unsigned long)result;
96968   return jresult;
96969 }
96970
96971
96972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96973   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96974   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96975
96976   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96977   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96978   {
96979     try {
96980       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96981     } catch (std::out_of_range& e) {
96982       {
96983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96984       };
96985     } catch (std::exception& e) {
96986       {
96987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96988       };
96989     } catch (Dali::DaliException e) {
96990       {
96991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96992       };
96993     } catch (...) {
96994       {
96995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96996       };
96997     }
96998   }
96999
97000 }
97001
97002
97003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
97004   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97005   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97006
97007   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97008   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97009   {
97010     try {
97011       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
97012     } catch (std::out_of_range& e) {
97013       {
97014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97015       };
97016     } catch (std::exception& e) {
97017       {
97018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97019       };
97020     } catch (Dali::DaliException e) {
97021       {
97022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97023       };
97024     } catch (...) {
97025       {
97026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97027       };
97028     }
97029   }
97030
97031 }
97032
97033
97034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
97035   unsigned int jresult ;
97036   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97037   Dali::Toolkit::Button arg2 ;
97038   Dali::Toolkit::Button *argp2 ;
97039   bool result;
97040
97041   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97042   argp2 = (Dali::Toolkit::Button *)jarg2;
97043   if (!argp2) {
97044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
97045     return 0;
97046   }
97047   arg2 = *argp2;
97048   {
97049     try {
97050       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
97051     } catch (std::out_of_range& e) {
97052       {
97053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97054       };
97055     } catch (std::exception& e) {
97056       {
97057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97058       };
97059     } catch (Dali::DaliException e) {
97060       {
97061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97062       };
97063     } catch (...) {
97064       {
97065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97066       };
97067     }
97068   }
97069
97070   jresult = result;
97071   return jresult;
97072 }
97073
97074
97075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97076   void * jresult ;
97077   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97078
97079   {
97080     try {
97081       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97082     } catch (std::out_of_range& e) {
97083       {
97084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97085       };
97086     } catch (std::exception& e) {
97087       {
97088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97089       };
97090     } catch (Dali::DaliException e) {
97091       {
97092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97093       };
97094     } catch (...) {
97095       {
97096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97097       };
97098     }
97099   }
97100
97101   jresult = (void *)result;
97102   return jresult;
97103 }
97104
97105
97106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97107   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97108
97109   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97110   {
97111     try {
97112       delete arg1;
97113     } catch (std::out_of_range& e) {
97114       {
97115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97116       };
97117     } catch (std::exception& e) {
97118       {
97119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97120       };
97121     } catch (Dali::DaliException e) {
97122       {
97123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97124       };
97125     } catch (...) {
97126       {
97127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97128       };
97129     }
97130   }
97131
97132 }
97133
97134
97135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97136   unsigned int jresult ;
97137   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97138   bool result;
97139
97140   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97141   {
97142     try {
97143       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97144     } catch (std::out_of_range& e) {
97145       {
97146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97147       };
97148     } catch (std::exception& e) {
97149       {
97150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97151       };
97152     } catch (Dali::DaliException e) {
97153       {
97154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97155       };
97156     } catch (...) {
97157       {
97158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97159       };
97160     }
97161   }
97162
97163   jresult = result;
97164   return jresult;
97165 }
97166
97167
97168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97169   unsigned long jresult ;
97170   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97171   std::size_t result;
97172
97173   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97174   {
97175     try {
97176       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97177     } catch (std::out_of_range& e) {
97178       {
97179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97180       };
97181     } catch (std::exception& e) {
97182       {
97183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97184       };
97185     } catch (Dali::DaliException e) {
97186       {
97187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97188       };
97189     } catch (...) {
97190       {
97191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97192       };
97193     }
97194   }
97195
97196   jresult = (unsigned long)result;
97197   return jresult;
97198 }
97199
97200
97201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97202   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97203   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97204
97205   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97206   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97207   {
97208     try {
97209       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97210     } catch (std::out_of_range& e) {
97211       {
97212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97213       };
97214     } catch (std::exception& e) {
97215       {
97216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97217       };
97218     } catch (Dali::DaliException e) {
97219       {
97220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97221       };
97222     } catch (...) {
97223       {
97224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97225       };
97226     }
97227   }
97228
97229 }
97230
97231
97232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97233   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97234   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97235
97236   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97237   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97238   {
97239     try {
97240       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97241     } catch (std::out_of_range& e) {
97242       {
97243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97244       };
97245     } catch (std::exception& e) {
97246       {
97247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97248       };
97249     } catch (Dali::DaliException e) {
97250       {
97251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97252       };
97253     } catch (...) {
97254       {
97255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97256       };
97257     }
97258   }
97259
97260 }
97261
97262
97263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97264   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97265   Dali::Toolkit::GaussianBlurView arg2 ;
97266   Dali::Toolkit::GaussianBlurView *argp2 ;
97267
97268   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97269   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97270   if (!argp2) {
97271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97272     return ;
97273   }
97274   arg2 = *argp2;
97275   {
97276     try {
97277       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97278     } catch (std::out_of_range& e) {
97279       {
97280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97281       };
97282     } catch (std::exception& e) {
97283       {
97284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97285       };
97286     } catch (Dali::DaliException e) {
97287       {
97288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97289       };
97290     } catch (...) {
97291       {
97292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97293       };
97294     }
97295   }
97296
97297 }
97298
97299
97300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97301   void * jresult ;
97302   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97303
97304   {
97305     try {
97306       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97307     } catch (std::out_of_range& e) {
97308       {
97309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97310       };
97311     } catch (std::exception& e) {
97312       {
97313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97314       };
97315     } catch (Dali::DaliException e) {
97316       {
97317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97318       };
97319     } catch (...) {
97320       {
97321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97322       };
97323     }
97324   }
97325
97326   jresult = (void *)result;
97327   return jresult;
97328 }
97329
97330
97331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97332   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97333
97334   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97335   {
97336     try {
97337       delete arg1;
97338     } catch (std::out_of_range& e) {
97339       {
97340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97341       };
97342     } catch (std::exception& e) {
97343       {
97344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97345       };
97346     } catch (Dali::DaliException e) {
97347       {
97348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97349       };
97350     } catch (...) {
97351       {
97352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97353       };
97354     }
97355   }
97356
97357 }
97358
97359
97360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97361   unsigned int jresult ;
97362   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97363   bool result;
97364
97365   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97366   {
97367     try {
97368       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);
97369     } catch (std::out_of_range& e) {
97370       {
97371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97372       };
97373     } catch (std::exception& e) {
97374       {
97375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97376       };
97377     } catch (Dali::DaliException e) {
97378       {
97379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97380       };
97381     } catch (...) {
97382       {
97383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97384       };
97385     }
97386   }
97387
97388   jresult = result;
97389   return jresult;
97390 }
97391
97392
97393 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97394   unsigned long jresult ;
97395   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97396   std::size_t result;
97397
97398   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97399   {
97400     try {
97401       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);
97402     } catch (std::out_of_range& e) {
97403       {
97404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97405       };
97406     } catch (std::exception& e) {
97407       {
97408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97409       };
97410     } catch (Dali::DaliException e) {
97411       {
97412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97413       };
97414     } catch (...) {
97415       {
97416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97417       };
97418     }
97419   }
97420
97421   jresult = (unsigned long)result;
97422   return jresult;
97423 }
97424
97425
97426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97427   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97428   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97429
97430   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97431   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97432   {
97433     try {
97434       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97435     } catch (std::out_of_range& e) {
97436       {
97437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97438       };
97439     } catch (std::exception& e) {
97440       {
97441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97442       };
97443     } catch (Dali::DaliException e) {
97444       {
97445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97446       };
97447     } catch (...) {
97448       {
97449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97450       };
97451     }
97452   }
97453
97454 }
97455
97456
97457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97458   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97459   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97460
97461   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97462   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97463   {
97464     try {
97465       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97466     } catch (std::out_of_range& e) {
97467       {
97468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97469       };
97470     } catch (std::exception& e) {
97471       {
97472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97473       };
97474     } catch (Dali::DaliException e) {
97475       {
97476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97477       };
97478     } catch (...) {
97479       {
97480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97481       };
97482     }
97483   }
97484
97485 }
97486
97487
97488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97489   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97490   Dali::Toolkit::PageTurnView arg2 ;
97491   unsigned int arg3 ;
97492   bool arg4 ;
97493   Dali::Toolkit::PageTurnView *argp2 ;
97494
97495   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97496   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97497   if (!argp2) {
97498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97499     return ;
97500   }
97501   arg2 = *argp2;
97502   arg3 = (unsigned int)jarg3;
97503   arg4 = jarg4 ? true : false;
97504   {
97505     try {
97506       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97507     } catch (std::out_of_range& e) {
97508       {
97509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97510       };
97511     } catch (std::exception& e) {
97512       {
97513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97514       };
97515     } catch (Dali::DaliException e) {
97516       {
97517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97518       };
97519     } catch (...) {
97520       {
97521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97522       };
97523     }
97524   }
97525
97526 }
97527
97528
97529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97530   void * jresult ;
97531   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97532
97533   {
97534     try {
97535       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97536     } catch (std::out_of_range& e) {
97537       {
97538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97539       };
97540     } catch (std::exception& e) {
97541       {
97542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97543       };
97544     } catch (Dali::DaliException e) {
97545       {
97546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97547       };
97548     } catch (...) {
97549       {
97550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97551       };
97552     }
97553   }
97554
97555   jresult = (void *)result;
97556   return jresult;
97557 }
97558
97559
97560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97561   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97562
97563   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97564   {
97565     try {
97566       delete arg1;
97567     } catch (std::out_of_range& e) {
97568       {
97569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97570       };
97571     } catch (std::exception& e) {
97572       {
97573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97574       };
97575     } catch (Dali::DaliException e) {
97576       {
97577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97578       };
97579     } catch (...) {
97580       {
97581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97582       };
97583     }
97584   }
97585
97586 }
97587
97588
97589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97590   unsigned int jresult ;
97591   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97592   bool result;
97593
97594   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97595   {
97596     try {
97597       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97598     } catch (std::out_of_range& e) {
97599       {
97600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97601       };
97602     } catch (std::exception& e) {
97603       {
97604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97605       };
97606     } catch (Dali::DaliException e) {
97607       {
97608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97609       };
97610     } catch (...) {
97611       {
97612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97613       };
97614     }
97615   }
97616
97617   jresult = result;
97618   return jresult;
97619 }
97620
97621
97622 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97623   unsigned long jresult ;
97624   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97625   std::size_t result;
97626
97627   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97628   {
97629     try {
97630       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97631     } catch (std::out_of_range& e) {
97632       {
97633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97634       };
97635     } catch (std::exception& e) {
97636       {
97637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97638       };
97639     } catch (Dali::DaliException e) {
97640       {
97641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97642       };
97643     } catch (...) {
97644       {
97645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97646       };
97647     }
97648   }
97649
97650   jresult = (unsigned long)result;
97651   return jresult;
97652 }
97653
97654
97655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97656   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97657   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97658
97659   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97660   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97661   {
97662     try {
97663       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97664     } catch (std::out_of_range& e) {
97665       {
97666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97667       };
97668     } catch (std::exception& e) {
97669       {
97670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97671       };
97672     } catch (Dali::DaliException e) {
97673       {
97674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97675       };
97676     } catch (...) {
97677       {
97678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97679       };
97680     }
97681   }
97682
97683 }
97684
97685
97686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97687   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97688   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97689
97690   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97691   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97692   {
97693     try {
97694       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97695     } catch (std::out_of_range& e) {
97696       {
97697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97698       };
97699     } catch (std::exception& e) {
97700       {
97701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97702       };
97703     } catch (Dali::DaliException e) {
97704       {
97705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97706       };
97707     } catch (...) {
97708       {
97709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97710       };
97711     }
97712   }
97713
97714 }
97715
97716
97717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97718   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97719   Dali::Toolkit::PageTurnView arg2 ;
97720   Dali::Toolkit::PageTurnView *argp2 ;
97721
97722   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97723   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97724   if (!argp2) {
97725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97726     return ;
97727   }
97728   arg2 = *argp2;
97729   {
97730     try {
97731       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97732     } catch (std::out_of_range& e) {
97733       {
97734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97735       };
97736     } catch (std::exception& e) {
97737       {
97738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97739       };
97740     } catch (Dali::DaliException e) {
97741       {
97742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97743       };
97744     } catch (...) {
97745       {
97746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97747       };
97748     }
97749   }
97750
97751 }
97752
97753
97754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97755   void * jresult ;
97756   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97757
97758   {
97759     try {
97760       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97761     } catch (std::out_of_range& e) {
97762       {
97763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97764       };
97765     } catch (std::exception& e) {
97766       {
97767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97768       };
97769     } catch (Dali::DaliException e) {
97770       {
97771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97772       };
97773     } catch (...) {
97774       {
97775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97776       };
97777     }
97778   }
97779
97780   jresult = (void *)result;
97781   return jresult;
97782 }
97783
97784
97785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97786   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97787
97788   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97789   {
97790     try {
97791       delete arg1;
97792     } catch (std::out_of_range& e) {
97793       {
97794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97795       };
97796     } catch (std::exception& e) {
97797       {
97798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97799       };
97800     } catch (Dali::DaliException e) {
97801       {
97802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97803       };
97804     } catch (...) {
97805       {
97806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97807       };
97808     }
97809   }
97810
97811 }
97812
97813
97814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97815   unsigned int jresult ;
97816   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97817   bool result;
97818
97819   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97820   {
97821     try {
97822       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);
97823     } catch (std::out_of_range& e) {
97824       {
97825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97826       };
97827     } catch (std::exception& e) {
97828       {
97829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97830       };
97831     } catch (Dali::DaliException e) {
97832       {
97833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97834       };
97835     } catch (...) {
97836       {
97837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97838       };
97839     }
97840   }
97841
97842   jresult = result;
97843   return jresult;
97844 }
97845
97846
97847 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97848   unsigned long jresult ;
97849   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97850   std::size_t result;
97851
97852   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97853   {
97854     try {
97855       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);
97856     } catch (std::out_of_range& e) {
97857       {
97858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97859       };
97860     } catch (std::exception& e) {
97861       {
97862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97863       };
97864     } catch (Dali::DaliException e) {
97865       {
97866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97867       };
97868     } catch (...) {
97869       {
97870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97871       };
97872     }
97873   }
97874
97875   jresult = (unsigned long)result;
97876   return jresult;
97877 }
97878
97879
97880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97881   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97882   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97883
97884   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97885   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97886   {
97887     try {
97888       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97889     } catch (std::out_of_range& e) {
97890       {
97891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97892       };
97893     } catch (std::exception& e) {
97894       {
97895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97896       };
97897     } catch (Dali::DaliException e) {
97898       {
97899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97900       };
97901     } catch (...) {
97902       {
97903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97904       };
97905     }
97906   }
97907
97908 }
97909
97910
97911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97912   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97913   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97914
97915   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97916   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97917   {
97918     try {
97919       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97920     } catch (std::out_of_range& e) {
97921       {
97922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97923       };
97924     } catch (std::exception& e) {
97925       {
97926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97927       };
97928     } catch (Dali::DaliException e) {
97929       {
97930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97931       };
97932     } catch (...) {
97933       {
97934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97935       };
97936     }
97937   }
97938
97939 }
97940
97941
97942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97943   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97944   Dali::Toolkit::ProgressBar arg2 ;
97945   float arg3 ;
97946   float arg4 ;
97947   Dali::Toolkit::ProgressBar *argp2 ;
97948
97949   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97950   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97951   if (!argp2) {
97952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97953     return ;
97954   }
97955   arg2 = *argp2;
97956   arg3 = (float)jarg3;
97957   arg4 = (float)jarg4;
97958   {
97959     try {
97960       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97961     } catch (std::out_of_range& e) {
97962       {
97963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97964       };
97965     } catch (std::exception& e) {
97966       {
97967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97968       };
97969     } catch (Dali::DaliException e) {
97970       {
97971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97972       };
97973     } catch (...) {
97974       {
97975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97976       };
97977     }
97978   }
97979
97980 }
97981
97982
97983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97984   void * jresult ;
97985   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97986
97987   {
97988     try {
97989       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97990     } catch (std::out_of_range& e) {
97991       {
97992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97993       };
97994     } catch (std::exception& e) {
97995       {
97996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97997       };
97998     } catch (Dali::DaliException e) {
97999       {
98000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98001       };
98002     } catch (...) {
98003       {
98004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98005       };
98006     }
98007   }
98008
98009   jresult = (void *)result;
98010   return jresult;
98011 }
98012
98013
98014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
98015   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98016
98017   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98018   {
98019     try {
98020       delete arg1;
98021     } catch (std::out_of_range& e) {
98022       {
98023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98024       };
98025     } catch (std::exception& e) {
98026       {
98027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98028       };
98029     } catch (Dali::DaliException e) {
98030       {
98031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98032       };
98033     } catch (...) {
98034       {
98035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98036       };
98037     }
98038   }
98039
98040 }
98041
98042
98043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
98044   unsigned int jresult ;
98045   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98046   bool result;
98047
98048   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98049   {
98050     try {
98051       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);
98052     } catch (std::out_of_range& e) {
98053       {
98054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98055       };
98056     } catch (std::exception& e) {
98057       {
98058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98059       };
98060     } catch (Dali::DaliException e) {
98061       {
98062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98063       };
98064     } catch (...) {
98065       {
98066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98067       };
98068     }
98069   }
98070
98071   jresult = result;
98072   return jresult;
98073 }
98074
98075
98076 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98077   unsigned long jresult ;
98078   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98079   std::size_t result;
98080
98081   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98082   {
98083     try {
98084       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);
98085     } catch (std::out_of_range& e) {
98086       {
98087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98088       };
98089     } catch (std::exception& e) {
98090       {
98091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98092       };
98093     } catch (Dali::DaliException e) {
98094       {
98095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98096       };
98097     } catch (...) {
98098       {
98099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98100       };
98101     }
98102   }
98103
98104   jresult = (unsigned long)result;
98105   return jresult;
98106 }
98107
98108
98109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98110   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98111   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98112
98113   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98114   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98115   {
98116     try {
98117       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98118     } catch (std::out_of_range& e) {
98119       {
98120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98121       };
98122     } catch (std::exception& e) {
98123       {
98124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98125       };
98126     } catch (Dali::DaliException e) {
98127       {
98128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98129       };
98130     } catch (...) {
98131       {
98132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98133       };
98134     }
98135   }
98136
98137 }
98138
98139
98140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98141   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98142   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98143
98144   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98145   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98146   {
98147     try {
98148       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98149     } catch (std::out_of_range& e) {
98150       {
98151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98152       };
98153     } catch (std::exception& e) {
98154       {
98155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98156       };
98157     } catch (Dali::DaliException e) {
98158       {
98159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98160       };
98161     } catch (...) {
98162       {
98163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98164       };
98165     }
98166   }
98167
98168 }
98169
98170
98171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98172   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98173   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98174
98175   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98176   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98177   if (!arg2) {
98178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98179     return ;
98180   }
98181   {
98182     try {
98183       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98184     } catch (std::out_of_range& e) {
98185       {
98186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98187       };
98188     } catch (std::exception& e) {
98189       {
98190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98191       };
98192     } catch (Dali::DaliException e) {
98193       {
98194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98195       };
98196     } catch (...) {
98197       {
98198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98199       };
98200     }
98201   }
98202
98203 }
98204
98205
98206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98207   void * jresult ;
98208   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98209
98210   {
98211     try {
98212       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98213     } catch (std::out_of_range& e) {
98214       {
98215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98216       };
98217     } catch (std::exception& e) {
98218       {
98219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98220       };
98221     } catch (Dali::DaliException e) {
98222       {
98223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98224       };
98225     } catch (...) {
98226       {
98227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98228       };
98229     }
98230   }
98231
98232   jresult = (void *)result;
98233   return jresult;
98234 }
98235
98236
98237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98238   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98239
98240   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98241   {
98242     try {
98243       delete arg1;
98244     } catch (std::out_of_range& e) {
98245       {
98246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98247       };
98248     } catch (std::exception& e) {
98249       {
98250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98251       };
98252     } catch (Dali::DaliException e) {
98253       {
98254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98255       };
98256     } catch (...) {
98257       {
98258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98259       };
98260     }
98261   }
98262
98263 }
98264
98265
98266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98267   unsigned int jresult ;
98268   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98269   bool result;
98270
98271   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98272   {
98273     try {
98274       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98275     } catch (std::out_of_range& e) {
98276       {
98277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98278       };
98279     } catch (std::exception& e) {
98280       {
98281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98282       };
98283     } catch (Dali::DaliException e) {
98284       {
98285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98286       };
98287     } catch (...) {
98288       {
98289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98290       };
98291     }
98292   }
98293
98294   jresult = result;
98295   return jresult;
98296 }
98297
98298
98299 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98300   unsigned long jresult ;
98301   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98302   std::size_t result;
98303
98304   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98305   {
98306     try {
98307       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98308     } catch (std::out_of_range& e) {
98309       {
98310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98311       };
98312     } catch (std::exception& e) {
98313       {
98314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98315       };
98316     } catch (Dali::DaliException e) {
98317       {
98318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98319       };
98320     } catch (...) {
98321       {
98322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98323       };
98324     }
98325   }
98326
98327   jresult = (unsigned long)result;
98328   return jresult;
98329 }
98330
98331
98332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98333   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98334   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98335
98336   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98337   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98338   {
98339     try {
98340       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98341     } catch (std::out_of_range& e) {
98342       {
98343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98344       };
98345     } catch (std::exception& e) {
98346       {
98347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98348       };
98349     } catch (Dali::DaliException e) {
98350       {
98351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98352       };
98353     } catch (...) {
98354       {
98355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98356       };
98357     }
98358   }
98359
98360 }
98361
98362
98363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98364   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98365   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98366
98367   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98368   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98369   {
98370     try {
98371       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98372     } catch (std::out_of_range& e) {
98373       {
98374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98375       };
98376     } catch (std::exception& e) {
98377       {
98378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98379       };
98380     } catch (Dali::DaliException e) {
98381       {
98382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98383       };
98384     } catch (...) {
98385       {
98386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98387       };
98388     }
98389   }
98390
98391 }
98392
98393
98394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98395   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98396   Dali::Vector2 *arg2 = 0 ;
98397
98398   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98399   arg2 = (Dali::Vector2 *)jarg2;
98400   if (!arg2) {
98401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98402     return ;
98403   }
98404   {
98405     try {
98406       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98407     } catch (std::out_of_range& e) {
98408       {
98409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98410       };
98411     } catch (std::exception& e) {
98412       {
98413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98414       };
98415     } catch (Dali::DaliException e) {
98416       {
98417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98418       };
98419     } catch (...) {
98420       {
98421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98422       };
98423     }
98424   }
98425
98426 }
98427
98428
98429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98430   void * jresult ;
98431   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98432
98433   {
98434     try {
98435       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98436     } catch (std::out_of_range& e) {
98437       {
98438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98439       };
98440     } catch (std::exception& e) {
98441       {
98442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98443       };
98444     } catch (Dali::DaliException e) {
98445       {
98446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98447       };
98448     } catch (...) {
98449       {
98450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98451       };
98452     }
98453   }
98454
98455   jresult = (void *)result;
98456   return jresult;
98457 }
98458
98459
98460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98461   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98462
98463   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98464   {
98465     try {
98466       delete arg1;
98467     } catch (std::out_of_range& e) {
98468       {
98469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98470       };
98471     } catch (std::exception& e) {
98472       {
98473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98474       };
98475     } catch (Dali::DaliException e) {
98476       {
98477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98478       };
98479     } catch (...) {
98480       {
98481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98482       };
98483     }
98484   }
98485
98486 }
98487
98488
98489
98490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98491   unsigned int jresult ;
98492   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98493   bool result;
98494
98495   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98496   {
98497     try {
98498       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);
98499     } catch (std::out_of_range& e) {
98500       {
98501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98502       };
98503     } catch (std::exception& e) {
98504       {
98505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98506       };
98507     } catch (Dali::DaliException e) {
98508       {
98509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98510       };
98511     } catch (...) {
98512       {
98513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98514       };
98515     }
98516   }
98517
98518   jresult = result;
98519   return jresult;
98520 }
98521
98522
98523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98524   unsigned long jresult ;
98525   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98526   std::size_t result;
98527
98528   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98529   {
98530     try {
98531       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);
98532     } catch (std::out_of_range& e) {
98533       {
98534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98535       };
98536     } catch (std::exception& e) {
98537       {
98538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98539       };
98540     } catch (Dali::DaliException e) {
98541       {
98542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98543       };
98544     } catch (...) {
98545       {
98546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98547       };
98548     }
98549   }
98550
98551   jresult = (unsigned long)result;
98552   return jresult;
98553 }
98554
98555
98556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98557   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98558   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98559
98560   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98561   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98562   {
98563     try {
98564       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98565     } catch (std::out_of_range& e) {
98566       {
98567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98568       };
98569     } catch (std::exception& e) {
98570       {
98571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98572       };
98573     } catch (Dali::DaliException e) {
98574       {
98575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98576       };
98577     } catch (...) {
98578       {
98579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98580       };
98581     }
98582   }
98583
98584 }
98585
98586
98587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98588   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98589   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98590
98591   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98592   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98593   {
98594     try {
98595       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98596     } catch (std::out_of_range& e) {
98597       {
98598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98599       };
98600     } catch (std::exception& e) {
98601       {
98602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98603       };
98604     } catch (Dali::DaliException e) {
98605       {
98606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98607       };
98608     } catch (...) {
98609       {
98610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98611       };
98612     }
98613   }
98614
98615 }
98616
98617
98618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98619   unsigned int jresult ;
98620   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98621   Dali::Toolkit::Control arg2 ;
98622   Dali::KeyEvent *arg3 = 0 ;
98623   Dali::Toolkit::Control *argp2 ;
98624   bool result;
98625
98626   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98627   argp2 = (Dali::Toolkit::Control *)jarg2;
98628   if (!argp2) {
98629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98630     return 0;
98631   }
98632   arg2 = *argp2;
98633   arg3 = (Dali::KeyEvent *)jarg3;
98634   if (!arg3) {
98635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98636     return 0;
98637   }
98638   {
98639     try {
98640       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);
98641     } catch (std::out_of_range& e) {
98642       {
98643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98644       };
98645     } catch (std::exception& e) {
98646       {
98647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98648       };
98649     } catch (Dali::DaliException e) {
98650       {
98651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98652       };
98653     } catch (...) {
98654       {
98655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98656       };
98657     }
98658   }
98659
98660   jresult = result;
98661   return jresult;
98662 }
98663
98664
98665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98666   void * jresult ;
98667   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98668
98669   {
98670     try {
98671       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98672     } catch (std::out_of_range& e) {
98673       {
98674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98675       };
98676     } catch (std::exception& e) {
98677       {
98678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98679       };
98680     } catch (Dali::DaliException e) {
98681       {
98682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98683       };
98684     } catch (...) {
98685       {
98686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98687       };
98688     }
98689   }
98690
98691   jresult = (void *)result;
98692   return jresult;
98693 }
98694
98695
98696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98697   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98698
98699   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98700   {
98701     try {
98702       delete arg1;
98703     } catch (std::out_of_range& e) {
98704       {
98705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98706       };
98707     } catch (std::exception& e) {
98708       {
98709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98710       };
98711     } catch (Dali::DaliException e) {
98712       {
98713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98714       };
98715     } catch (...) {
98716       {
98717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98718       };
98719     }
98720   }
98721
98722 }
98723
98724
98725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98726   unsigned int jresult ;
98727   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98728   bool result;
98729
98730   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98731   {
98732     try {
98733       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98734     } catch (std::out_of_range& e) {
98735       {
98736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98737       };
98738     } catch (std::exception& e) {
98739       {
98740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98741       };
98742     } catch (Dali::DaliException e) {
98743       {
98744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98745       };
98746     } catch (...) {
98747       {
98748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98749       };
98750     }
98751   }
98752
98753   jresult = result;
98754   return jresult;
98755 }
98756
98757
98758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98759   unsigned long jresult ;
98760   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98761   std::size_t result;
98762
98763   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98764   {
98765     try {
98766       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98767     } catch (std::out_of_range& e) {
98768       {
98769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98770       };
98771     } catch (std::exception& e) {
98772       {
98773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98774       };
98775     } catch (Dali::DaliException e) {
98776       {
98777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98778       };
98779     } catch (...) {
98780       {
98781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98782       };
98783     }
98784   }
98785
98786   jresult = (unsigned long)result;
98787   return jresult;
98788 }
98789
98790
98791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98792   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98793   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98794
98795   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98796   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98797   {
98798     try {
98799       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98800     } catch (std::out_of_range& e) {
98801       {
98802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98803       };
98804     } catch (std::exception& e) {
98805       {
98806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98807       };
98808     } catch (Dali::DaliException e) {
98809       {
98810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98811       };
98812     } catch (...) {
98813       {
98814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98815       };
98816     }
98817   }
98818
98819 }
98820
98821
98822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98823   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98824   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98825
98826   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98827   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98828   {
98829     try {
98830       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98831     } catch (std::out_of_range& e) {
98832       {
98833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98834       };
98835     } catch (std::exception& e) {
98836       {
98837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98838       };
98839     } catch (Dali::DaliException e) {
98840       {
98841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98842       };
98843     } catch (...) {
98844       {
98845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98846       };
98847     }
98848   }
98849
98850 }
98851
98852
98853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98854   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98855   Dali::Toolkit::Control arg2 ;
98856   Dali::Toolkit::Control *argp2 ;
98857
98858   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98859   argp2 = (Dali::Toolkit::Control *)jarg2;
98860   if (!argp2) {
98861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98862     return ;
98863   }
98864   arg2 = *argp2;
98865   {
98866     try {
98867       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98868     } catch (std::out_of_range& e) {
98869       {
98870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98871       };
98872     } catch (std::exception& e) {
98873       {
98874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98875       };
98876     } catch (Dali::DaliException e) {
98877       {
98878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98879       };
98880     } catch (...) {
98881       {
98882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98883       };
98884     }
98885   }
98886
98887 }
98888
98889
98890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98891   void * jresult ;
98892   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98893
98894   {
98895     try {
98896       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98897     } catch (std::out_of_range& e) {
98898       {
98899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98900       };
98901     } catch (std::exception& e) {
98902       {
98903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98904       };
98905     } catch (Dali::DaliException e) {
98906       {
98907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98908       };
98909     } catch (...) {
98910       {
98911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98912       };
98913     }
98914   }
98915
98916   jresult = (void *)result;
98917   return jresult;
98918 }
98919
98920
98921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98922   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98923
98924   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98925   {
98926     try {
98927       delete arg1;
98928     } catch (std::out_of_range& e) {
98929       {
98930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98931       };
98932     } catch (std::exception& e) {
98933       {
98934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98935       };
98936     } catch (Dali::DaliException e) {
98937       {
98938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98939       };
98940     } catch (...) {
98941       {
98942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98943       };
98944     }
98945   }
98946
98947 }
98948
98949
98950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98951   unsigned int jresult ;
98952   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98953   bool result;
98954
98955   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98956   {
98957     try {
98958       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98959     } catch (std::out_of_range& e) {
98960       {
98961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98962       };
98963     } catch (std::exception& e) {
98964       {
98965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98966       };
98967     } catch (Dali::DaliException e) {
98968       {
98969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98970       };
98971     } catch (...) {
98972       {
98973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98974       };
98975     }
98976   }
98977
98978   jresult = result;
98979   return jresult;
98980 }
98981
98982
98983 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98984   unsigned long jresult ;
98985   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98986   std::size_t result;
98987
98988   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98989   {
98990     try {
98991       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98992     } catch (std::out_of_range& e) {
98993       {
98994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98995       };
98996     } catch (std::exception& e) {
98997       {
98998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98999       };
99000     } catch (Dali::DaliException e) {
99001       {
99002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99003       };
99004     } catch (...) {
99005       {
99006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99007       };
99008     }
99009   }
99010
99011   jresult = (unsigned long)result;
99012   return jresult;
99013 }
99014
99015
99016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
99017   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99018   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99019
99020   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99021   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99022   {
99023     try {
99024       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
99025     } catch (std::out_of_range& e) {
99026       {
99027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99028       };
99029     } catch (std::exception& e) {
99030       {
99031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99032       };
99033     } catch (Dali::DaliException e) {
99034       {
99035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99036       };
99037     } catch (...) {
99038       {
99039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99040       };
99041     }
99042   }
99043
99044 }
99045
99046
99047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
99048   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99049   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99050
99051   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99052   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99053   {
99054     try {
99055       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
99056     } catch (std::out_of_range& e) {
99057       {
99058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99059       };
99060     } catch (std::exception& e) {
99061       {
99062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99063       };
99064     } catch (Dali::DaliException e) {
99065       {
99066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99067       };
99068     } catch (...) {
99069       {
99070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99071       };
99072     }
99073   }
99074
99075 }
99076
99077
99078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99079   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99080   Dali::Toolkit::VideoView *arg2 = 0 ;
99081
99082   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99083   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99084   if (!arg2) {
99085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99086     return ;
99087   }
99088   {
99089     try {
99090       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99091     } catch (std::out_of_range& e) {
99092       {
99093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99094       };
99095     } catch (std::exception& e) {
99096       {
99097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99098       };
99099     } catch (Dali::DaliException e) {
99100       {
99101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99102       };
99103     } catch (...) {
99104       {
99105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99106       };
99107     }
99108   }
99109
99110 }
99111
99112
99113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99114   void * jresult ;
99115   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99116
99117   {
99118     try {
99119       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99120     } catch (std::out_of_range& e) {
99121       {
99122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99123       };
99124     } catch (std::exception& e) {
99125       {
99126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99127       };
99128     } catch (Dali::DaliException e) {
99129       {
99130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99131       };
99132     } catch (...) {
99133       {
99134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99135       };
99136     }
99137   }
99138
99139   jresult = (void *)result;
99140   return jresult;
99141 }
99142
99143
99144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99145   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99146
99147   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99148   {
99149     try {
99150       delete arg1;
99151     } catch (std::out_of_range& e) {
99152       {
99153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99154       };
99155     } catch (std::exception& e) {
99156       {
99157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99158       };
99159     } catch (Dali::DaliException e) {
99160       {
99161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99162       };
99163     } catch (...) {
99164       {
99165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99166       };
99167     }
99168   }
99169
99170 }
99171
99172
99173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99174   unsigned int jresult ;
99175   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99176   bool result;
99177
99178   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99179   {
99180     try {
99181       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99182     } catch (std::out_of_range& e) {
99183       {
99184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99185       };
99186     } catch (std::exception& e) {
99187       {
99188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99189       };
99190     } catch (Dali::DaliException e) {
99191       {
99192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99193       };
99194     } catch (...) {
99195       {
99196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99197       };
99198     }
99199   }
99200
99201   jresult = result;
99202   return jresult;
99203 }
99204
99205
99206 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99207   unsigned long jresult ;
99208   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99209   std::size_t result;
99210
99211   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99212   {
99213     try {
99214       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99215     } catch (std::out_of_range& e) {
99216       {
99217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99218       };
99219     } catch (std::exception& e) {
99220       {
99221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99222       };
99223     } catch (Dali::DaliException e) {
99224       {
99225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99226       };
99227     } catch (...) {
99228       {
99229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99230       };
99231     }
99232   }
99233
99234   jresult = (unsigned long)result;
99235   return jresult;
99236 }
99237
99238
99239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99240   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99241   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99242
99243   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99244   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99245   {
99246     try {
99247       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99248     } catch (std::out_of_range& e) {
99249       {
99250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99251       };
99252     } catch (std::exception& e) {
99253       {
99254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99255       };
99256     } catch (Dali::DaliException e) {
99257       {
99258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99259       };
99260     } catch (...) {
99261       {
99262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99263       };
99264     }
99265   }
99266
99267 }
99268
99269
99270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99271   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99272   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99273
99274   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99275   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99276   {
99277     try {
99278       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99279     } catch (std::out_of_range& e) {
99280       {
99281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99282       };
99283     } catch (std::exception& e) {
99284       {
99285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99286       };
99287     } catch (Dali::DaliException e) {
99288       {
99289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99290       };
99291     } catch (...) {
99292       {
99293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99294       };
99295     }
99296   }
99297
99298 }
99299
99300
99301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99302   unsigned int jresult ;
99303   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99304   Dali::Toolkit::Slider arg2 ;
99305   float arg3 ;
99306   Dali::Toolkit::Slider *argp2 ;
99307   bool result;
99308
99309   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99310   argp2 = (Dali::Toolkit::Slider *)jarg2;
99311   if (!argp2) {
99312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99313     return 0;
99314   }
99315   arg2 = *argp2;
99316   arg3 = (float)jarg3;
99317   {
99318     try {
99319       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99320     } catch (std::out_of_range& e) {
99321       {
99322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99323       };
99324     } catch (std::exception& e) {
99325       {
99326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99327       };
99328     } catch (Dali::DaliException e) {
99329       {
99330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99331       };
99332     } catch (...) {
99333       {
99334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99335       };
99336     }
99337   }
99338
99339   jresult = result;
99340   return jresult;
99341 }
99342
99343
99344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99345   void * jresult ;
99346   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99347
99348   {
99349     try {
99350       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99351     } catch (std::out_of_range& e) {
99352       {
99353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99354       };
99355     } catch (std::exception& e) {
99356       {
99357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99358       };
99359     } catch (Dali::DaliException e) {
99360       {
99361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99362       };
99363     } catch (...) {
99364       {
99365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99366       };
99367     }
99368   }
99369
99370   jresult = (void *)result;
99371   return jresult;
99372 }
99373
99374
99375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99376   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99377
99378   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99379   {
99380     try {
99381       delete arg1;
99382     } catch (std::out_of_range& e) {
99383       {
99384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99385       };
99386     } catch (std::exception& e) {
99387       {
99388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99389       };
99390     } catch (Dali::DaliException e) {
99391       {
99392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99393       };
99394     } catch (...) {
99395       {
99396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99397       };
99398     }
99399   }
99400
99401 }
99402
99403
99404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99405   unsigned int jresult ;
99406   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99407   bool result;
99408
99409   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99410   {
99411     try {
99412       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99413     } catch (std::out_of_range& e) {
99414       {
99415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99416       };
99417     } catch (std::exception& e) {
99418       {
99419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99420       };
99421     } catch (Dali::DaliException e) {
99422       {
99423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99424       };
99425     } catch (...) {
99426       {
99427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99428       };
99429     }
99430   }
99431
99432   jresult = result;
99433   return jresult;
99434 }
99435
99436
99437 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99438   unsigned long jresult ;
99439   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99440   std::size_t result;
99441
99442   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99443   {
99444     try {
99445       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99446     } catch (std::out_of_range& e) {
99447       {
99448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99449       };
99450     } catch (std::exception& e) {
99451       {
99452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99453       };
99454     } catch (Dali::DaliException e) {
99455       {
99456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99457       };
99458     } catch (...) {
99459       {
99460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99461       };
99462     }
99463   }
99464
99465   jresult = (unsigned long)result;
99466   return jresult;
99467 }
99468
99469
99470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99471   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99472   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99473
99474   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99475   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99476   {
99477     try {
99478       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99479     } catch (std::out_of_range& e) {
99480       {
99481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99482       };
99483     } catch (std::exception& e) {
99484       {
99485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99486       };
99487     } catch (Dali::DaliException e) {
99488       {
99489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99490       };
99491     } catch (...) {
99492       {
99493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99494       };
99495     }
99496   }
99497
99498 }
99499
99500
99501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99502   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99503   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99504
99505   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99506   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99507   {
99508     try {
99509       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99510     } catch (std::out_of_range& e) {
99511       {
99512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99513       };
99514     } catch (std::exception& e) {
99515       {
99516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99517       };
99518     } catch (Dali::DaliException e) {
99519       {
99520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99521       };
99522     } catch (...) {
99523       {
99524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99525       };
99526     }
99527   }
99528
99529 }
99530
99531
99532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99533   unsigned int jresult ;
99534   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99535   Dali::Toolkit::Slider arg2 ;
99536   int arg3 ;
99537   Dali::Toolkit::Slider *argp2 ;
99538   bool result;
99539
99540   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99541   argp2 = (Dali::Toolkit::Slider *)jarg2;
99542   if (!argp2) {
99543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99544     return 0;
99545   }
99546   arg2 = *argp2;
99547   arg3 = (int)jarg3;
99548   {
99549     try {
99550       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99551     } catch (std::out_of_range& e) {
99552       {
99553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99554       };
99555     } catch (std::exception& e) {
99556       {
99557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99558       };
99559     } catch (Dali::DaliException e) {
99560       {
99561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99562       };
99563     } catch (...) {
99564       {
99565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99566       };
99567     }
99568   }
99569
99570   jresult = result;
99571   return jresult;
99572 }
99573
99574
99575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99576   void * jresult ;
99577   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99578
99579   {
99580     try {
99581       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99582     } catch (std::out_of_range& e) {
99583       {
99584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99585       };
99586     } catch (std::exception& e) {
99587       {
99588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99589       };
99590     } catch (Dali::DaliException e) {
99591       {
99592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99593       };
99594     } catch (...) {
99595       {
99596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99597       };
99598     }
99599   }
99600
99601   jresult = (void *)result;
99602   return jresult;
99603 }
99604
99605
99606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99607   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99608
99609   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99610   {
99611     try {
99612       delete arg1;
99613     } catch (std::out_of_range& e) {
99614       {
99615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99616       };
99617     } catch (std::exception& e) {
99618       {
99619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99620       };
99621     } catch (Dali::DaliException e) {
99622       {
99623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99624       };
99625     } catch (...) {
99626       {
99627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99628       };
99629     }
99630   }
99631
99632 }
99633
99634
99635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99636   void * jresult ;
99637   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99638
99639   {
99640     try {
99641       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99642     } catch (std::out_of_range& e) {
99643       {
99644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99645       };
99646     } catch (std::exception& e) {
99647       {
99648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99649       };
99650     } catch (Dali::DaliException e) {
99651       {
99652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99653       };
99654     } catch (...) {
99655       {
99656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99657       };
99658     }
99659   }
99660
99661   jresult = (void *)result;
99662   return jresult;
99663 }
99664
99665
99666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99667   void * jresult ;
99668   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99669   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99670
99671   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99672   {
99673     try {
99674       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99675     } catch (std::out_of_range& e) {
99676       {
99677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99678       };
99679     } catch (std::exception& e) {
99680       {
99681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99682       };
99683     } catch (Dali::DaliException e) {
99684       {
99685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99686       };
99687     } catch (...) {
99688       {
99689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99690       };
99691     }
99692   }
99693
99694   jresult = (void *)result;
99695   return jresult;
99696 }
99697
99698
99699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99700   void * jresult ;
99701   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99702   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99703
99704   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99705   if (!arg1) {
99706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99707     return 0;
99708   }
99709   {
99710     try {
99711       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99712     } catch (std::out_of_range& e) {
99713       {
99714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99715       };
99716     } catch (std::exception& e) {
99717       {
99718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99719       };
99720     } catch (Dali::DaliException e) {
99721       {
99722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99723       };
99724     } catch (...) {
99725       {
99726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99727       };
99728     }
99729   }
99730
99731   jresult = (void *)result;
99732   return jresult;
99733 }
99734
99735
99736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99737   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99738
99739   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99740   {
99741     try {
99742       delete arg1;
99743     } catch (std::out_of_range& e) {
99744       {
99745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99746       };
99747     } catch (std::exception& e) {
99748       {
99749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99750       };
99751     } catch (Dali::DaliException e) {
99752       {
99753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99754       };
99755     } catch (...) {
99756       {
99757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99758       };
99759     }
99760   }
99761
99762 }
99763
99764
99765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99766   void * jresult ;
99767   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99768   Dali::Toolkit::Ruler *result = 0 ;
99769
99770   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99771   {
99772     try {
99773       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99774     } catch (std::out_of_range& e) {
99775       {
99776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99777       };
99778     } catch (std::exception& e) {
99779       {
99780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99781       };
99782     } catch (Dali::DaliException e) {
99783       {
99784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99785       };
99786     } catch (...) {
99787       {
99788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99789       };
99790     }
99791   }
99792
99793   jresult = (void *)result;
99794   return jresult;
99795 }
99796
99797
99798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99799   void * jresult ;
99800   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99801   Dali::Toolkit::Ruler *result = 0 ;
99802
99803   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99804   {
99805     try {
99806       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99807     } catch (std::out_of_range& e) {
99808       {
99809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99810       };
99811     } catch (std::exception& e) {
99812       {
99813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99814       };
99815     } catch (Dali::DaliException e) {
99816       {
99817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99818       };
99819     } catch (...) {
99820       {
99821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99822       };
99823     }
99824   }
99825
99826   jresult = (void *)result;
99827   return jresult;
99828 }
99829
99830
99831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99832   void * jresult ;
99833   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99834   Dali::Toolkit::Ruler *result = 0 ;
99835
99836   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99837   {
99838     try {
99839       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99840     } catch (std::out_of_range& e) {
99841       {
99842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99843       };
99844     } catch (std::exception& e) {
99845       {
99846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99847       };
99848     } catch (Dali::DaliException e) {
99849       {
99850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99851       };
99852     } catch (...) {
99853       {
99854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99855       };
99856     }
99857   }
99858
99859   jresult = (void *)result;
99860   return jresult;
99861 }
99862
99863
99864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99865   void * jresult ;
99866   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99867   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99868   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99869
99870   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99871   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99872   if (!arg2) {
99873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99874     return 0;
99875   }
99876   {
99877     try {
99878       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99879     } catch (std::out_of_range& e) {
99880       {
99881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99882       };
99883     } catch (std::exception& e) {
99884       {
99885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99886       };
99887     } catch (Dali::DaliException e) {
99888       {
99889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99890       };
99891     } catch (...) {
99892       {
99893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99894       };
99895     }
99896   }
99897
99898   jresult = (void *)result;
99899   return jresult;
99900 }
99901
99902
99903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99904   void * jresult ;
99905   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99906   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99907   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99908
99909   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99910   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99911   {
99912     try {
99913       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99914     } catch (std::out_of_range& e) {
99915       {
99916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99917       };
99918     } catch (std::exception& e) {
99919       {
99920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99921       };
99922     } catch (Dali::DaliException e) {
99923       {
99924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99925       };
99926     } catch (...) {
99927       {
99928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99929       };
99930     }
99931   }
99932
99933   jresult = (void *)result;
99934   return jresult;
99935 }
99936
99937
99938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99939   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99940
99941   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99942   {
99943     try {
99944       (arg1)->Reset();
99945     } catch (std::out_of_range& e) {
99946       {
99947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99948       };
99949     } catch (std::exception& e) {
99950       {
99951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99952       };
99953     } catch (Dali::DaliException e) {
99954       {
99955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99956       };
99957     } catch (...) {
99958       {
99959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99960       };
99961     }
99962   }
99963
99964 }
99965
99966
99967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99968   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99969   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99970
99971   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99972   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99973   {
99974     try {
99975       (arg1)->Reset(arg2);
99976     } catch (std::out_of_range& e) {
99977       {
99978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99979       };
99980     } catch (std::exception& e) {
99981       {
99982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99983       };
99984     } catch (Dali::DaliException e) {
99985       {
99986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99987       };
99988     } catch (...) {
99989       {
99990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99991       };
99992     }
99993   }
99994
99995 }
99996
99997
99998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99999   void * jresult ;
100000   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100001   Dali::Toolkit::Ruler *result = 0 ;
100002
100003   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100004   {
100005     try {
100006       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
100007     } catch (std::out_of_range& e) {
100008       {
100009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100010       };
100011     } catch (std::exception& e) {
100012       {
100013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100014       };
100015     } catch (Dali::DaliException e) {
100016       {
100017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100018       };
100019     } catch (...) {
100020       {
100021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100022       };
100023     }
100024   }
100025
100026   jresult = (void *)result;
100027   return jresult;
100028 }
100029
100030
100031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
100032   float jresult ;
100033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100034   float arg2 ;
100035   float arg3 ;
100036   float result;
100037
100038   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100039   arg2 = (float)jarg2;
100040   arg3 = (float)jarg3;
100041   {
100042     try {
100043       result = (float)(*arg1)->Snap(arg2,arg3);
100044     } catch (std::out_of_range& e) {
100045       {
100046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100047       };
100048     } catch (std::exception& e) {
100049       {
100050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100051       };
100052     } catch (Dali::DaliException e) {
100053       {
100054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100055       };
100056     } catch (...) {
100057       {
100058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100059       };
100060     }
100061   }
100062
100063   jresult = result;
100064   return jresult;
100065 }
100066
100067
100068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
100069   float jresult ;
100070   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100071   float arg2 ;
100072   float result;
100073
100074   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100075   arg2 = (float)jarg2;
100076   {
100077     try {
100078       result = (float)(*arg1)->Snap(arg2);
100079     } catch (std::out_of_range& e) {
100080       {
100081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100082       };
100083     } catch (std::exception& e) {
100084       {
100085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100086       };
100087     } catch (Dali::DaliException e) {
100088       {
100089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100090       };
100091     } catch (...) {
100092       {
100093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100094       };
100095     }
100096   }
100097
100098   jresult = result;
100099   return jresult;
100100 }
100101
100102
100103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100104   float jresult ;
100105   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100106   unsigned int arg2 ;
100107   unsigned int *arg3 = 0 ;
100108   bool arg4 ;
100109   float result;
100110
100111   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100112   arg2 = (unsigned int)jarg2;
100113   arg3 = (unsigned int *)jarg3;
100114   arg4 = jarg4 ? true : false;
100115   {
100116     try {
100117       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100118     } catch (std::out_of_range& e) {
100119       {
100120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100121       };
100122     } catch (std::exception& e) {
100123       {
100124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100125       };
100126     } catch (Dali::DaliException e) {
100127       {
100128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100129       };
100130     } catch (...) {
100131       {
100132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100133       };
100134     }
100135   }
100136
100137   jresult = result;
100138   return jresult;
100139 }
100140
100141
100142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100143   unsigned int jresult ;
100144   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100145   float arg2 ;
100146   bool arg3 ;
100147   unsigned int result;
100148
100149   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100150   arg2 = (float)jarg2;
100151   arg3 = jarg3 ? true : false;
100152   {
100153     try {
100154       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100155     } catch (std::out_of_range& e) {
100156       {
100157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100158       };
100159     } catch (std::exception& e) {
100160       {
100161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100162       };
100163     } catch (Dali::DaliException e) {
100164       {
100165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100166       };
100167     } catch (...) {
100168       {
100169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100170       };
100171     }
100172   }
100173
100174   jresult = result;
100175   return jresult;
100176 }
100177
100178
100179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100180   unsigned int jresult ;
100181   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100182   unsigned int result;
100183
100184   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100185   {
100186     try {
100187       result = (unsigned int)(*arg1)->GetTotalPages();
100188     } catch (std::out_of_range& e) {
100189       {
100190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100191       };
100192     } catch (std::exception& e) {
100193       {
100194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100195       };
100196     } catch (Dali::DaliException e) {
100197       {
100198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100199       };
100200     } catch (...) {
100201       {
100202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100203       };
100204     }
100205   }
100206
100207   jresult = result;
100208   return jresult;
100209 }
100210
100211
100212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100213   int jresult ;
100214   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100215   Dali::Toolkit::Ruler::RulerType result;
100216
100217   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100218   {
100219     try {
100220       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100221     } catch (std::out_of_range& e) {
100222       {
100223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100224       };
100225     } catch (std::exception& e) {
100226       {
100227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100228       };
100229     } catch (Dali::DaliException e) {
100230       {
100231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100232       };
100233     } catch (...) {
100234       {
100235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100236       };
100237     }
100238   }
100239
100240   jresult = (int)result;
100241   return jresult;
100242 }
100243
100244
100245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100246   unsigned int jresult ;
100247   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100248   bool result;
100249
100250   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100251   {
100252     try {
100253       result = (bool)(*arg1)->IsEnabled();
100254     } catch (std::out_of_range& e) {
100255       {
100256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100257       };
100258     } catch (std::exception& e) {
100259       {
100260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100261       };
100262     } catch (Dali::DaliException e) {
100263       {
100264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100265       };
100266     } catch (...) {
100267       {
100268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100269       };
100270     }
100271   }
100272
100273   jresult = result;
100274   return jresult;
100275 }
100276
100277
100278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100279   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100280
100281   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100282   {
100283     try {
100284       (*arg1)->Enable();
100285     } catch (std::out_of_range& e) {
100286       {
100287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100288       };
100289     } catch (std::exception& e) {
100290       {
100291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100292       };
100293     } catch (Dali::DaliException e) {
100294       {
100295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100296       };
100297     } catch (...) {
100298       {
100299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100300       };
100301     }
100302   }
100303
100304 }
100305
100306
100307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100308   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100309
100310   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100311   {
100312     try {
100313       (*arg1)->Disable();
100314     } catch (std::out_of_range& e) {
100315       {
100316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100317       };
100318     } catch (std::exception& e) {
100319       {
100320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100321       };
100322     } catch (Dali::DaliException e) {
100323       {
100324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100325       };
100326     } catch (...) {
100327       {
100328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100329       };
100330     }
100331   }
100332
100333 }
100334
100335
100336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100337   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100338   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100339   Dali::Toolkit::RulerDomain *argp2 ;
100340
100341   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100342   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100343   if (!argp2) {
100344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100345     return ;
100346   }
100347   arg2 = *argp2;
100348   {
100349     try {
100350       (*arg1)->SetDomain(arg2);
100351     } catch (std::out_of_range& e) {
100352       {
100353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100354       };
100355     } catch (std::exception& e) {
100356       {
100357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100358       };
100359     } catch (Dali::DaliException e) {
100360       {
100361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100362       };
100363     } catch (...) {
100364       {
100365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100366       };
100367     }
100368   }
100369
100370 }
100371
100372
100373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100374   void * jresult ;
100375   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100376   Dali::Toolkit::RulerDomain *result = 0 ;
100377
100378   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100379   {
100380     try {
100381       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100382     } catch (std::out_of_range& e) {
100383       {
100384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100385       };
100386     } catch (std::exception& e) {
100387       {
100388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100389       };
100390     } catch (Dali::DaliException e) {
100391       {
100392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100393       };
100394     } catch (...) {
100395       {
100396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100397       };
100398     }
100399   }
100400
100401   jresult = (void *)result;
100402   return jresult;
100403 }
100404
100405
100406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100407   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100408
100409   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100410   {
100411     try {
100412       (*arg1)->DisableDomain();
100413     } catch (std::out_of_range& e) {
100414       {
100415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100416       };
100417     } catch (std::exception& e) {
100418       {
100419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100420       };
100421     } catch (Dali::DaliException e) {
100422       {
100423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100424       };
100425     } catch (...) {
100426       {
100427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100428       };
100429     }
100430   }
100431
100432 }
100433
100434
100435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100436   float jresult ;
100437   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100438   float arg2 ;
100439   float arg3 ;
100440   float arg4 ;
100441   float result;
100442
100443   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100444   arg2 = (float)jarg2;
100445   arg3 = (float)jarg3;
100446   arg4 = (float)jarg4;
100447   {
100448     try {
100449       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100450     } catch (std::out_of_range& e) {
100451       {
100452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100453       };
100454     } catch (std::exception& e) {
100455       {
100456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100457       };
100458     } catch (Dali::DaliException e) {
100459       {
100460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100461       };
100462     } catch (...) {
100463       {
100464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100465       };
100466     }
100467   }
100468
100469   jresult = result;
100470   return jresult;
100471 }
100472
100473
100474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100475   float jresult ;
100476   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100477   float arg2 ;
100478   float arg3 ;
100479   float result;
100480
100481   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100482   arg2 = (float)jarg2;
100483   arg3 = (float)jarg3;
100484   {
100485     try {
100486       result = (float)(*arg1)->Clamp(arg2,arg3);
100487     } catch (std::out_of_range& e) {
100488       {
100489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100490       };
100491     } catch (std::exception& e) {
100492       {
100493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100494       };
100495     } catch (Dali::DaliException e) {
100496       {
100497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100498       };
100499     } catch (...) {
100500       {
100501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100502       };
100503     }
100504   }
100505
100506   jresult = result;
100507   return jresult;
100508 }
100509
100510
100511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100512   float jresult ;
100513   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100514   float arg2 ;
100515   float result;
100516
100517   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100518   arg2 = (float)jarg2;
100519   {
100520     try {
100521       result = (float)(*arg1)->Clamp(arg2);
100522     } catch (std::out_of_range& e) {
100523       {
100524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100525       };
100526     } catch (std::exception& e) {
100527       {
100528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100529       };
100530     } catch (Dali::DaliException e) {
100531       {
100532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100533       };
100534     } catch (...) {
100535       {
100536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100537       };
100538     }
100539   }
100540
100541   jresult = result;
100542   return jresult;
100543 }
100544
100545
100546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100547   float jresult ;
100548   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100549   float arg2 ;
100550   float arg3 ;
100551   float arg4 ;
100552   Dali::Toolkit::ClampState *arg5 = 0 ;
100553   float result;
100554
100555   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100556   arg2 = (float)jarg2;
100557   arg3 = (float)jarg3;
100558   arg4 = (float)jarg4;
100559   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100560   if (!arg5) {
100561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100562     return 0;
100563   }
100564   {
100565     try {
100566       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100567     } catch (std::out_of_range& e) {
100568       {
100569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100570       };
100571     } catch (std::exception& e) {
100572       {
100573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100574       };
100575     } catch (Dali::DaliException e) {
100576       {
100577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100578       };
100579     } catch (...) {
100580       {
100581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100582       };
100583     }
100584   }
100585
100586   jresult = result;
100587   return jresult;
100588 }
100589
100590
100591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100592   float jresult ;
100593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100594   float arg2 ;
100595   float arg3 ;
100596   float arg4 ;
100597   float arg5 ;
100598   float result;
100599
100600   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100601   arg2 = (float)jarg2;
100602   arg3 = (float)jarg3;
100603   arg4 = (float)jarg4;
100604   arg5 = (float)jarg5;
100605   {
100606     try {
100607       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100608     } catch (std::out_of_range& e) {
100609       {
100610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100611       };
100612     } catch (std::exception& e) {
100613       {
100614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100615       };
100616     } catch (Dali::DaliException e) {
100617       {
100618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100619       };
100620     } catch (...) {
100621       {
100622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100623       };
100624     }
100625   }
100626
100627   jresult = result;
100628   return jresult;
100629 }
100630
100631
100632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100633   float jresult ;
100634   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100635   float arg2 ;
100636   float arg3 ;
100637   float arg4 ;
100638   float result;
100639
100640   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100641   arg2 = (float)jarg2;
100642   arg3 = (float)jarg3;
100643   arg4 = (float)jarg4;
100644   {
100645     try {
100646       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100647     } catch (std::out_of_range& e) {
100648       {
100649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100650       };
100651     } catch (std::exception& e) {
100652       {
100653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100654       };
100655     } catch (Dali::DaliException e) {
100656       {
100657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100658       };
100659     } catch (...) {
100660       {
100661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100662       };
100663     }
100664   }
100665
100666   jresult = result;
100667   return jresult;
100668 }
100669
100670
100671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100672   float jresult ;
100673   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100674   float arg2 ;
100675   float arg3 ;
100676   float result;
100677
100678   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100679   arg2 = (float)jarg2;
100680   arg3 = (float)jarg3;
100681   {
100682     try {
100683       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100684     } catch (std::out_of_range& e) {
100685       {
100686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100687       };
100688     } catch (std::exception& e) {
100689       {
100690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100691       };
100692     } catch (Dali::DaliException e) {
100693       {
100694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100695       };
100696     } catch (...) {
100697       {
100698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100699       };
100700     }
100701   }
100702
100703   jresult = result;
100704   return jresult;
100705 }
100706
100707
100708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100709   float jresult ;
100710   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100711   float arg2 ;
100712   float result;
100713
100714   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100715   arg2 = (float)jarg2;
100716   {
100717     try {
100718       result = (float)(*arg1)->SnapAndClamp(arg2);
100719     } catch (std::out_of_range& e) {
100720       {
100721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100722       };
100723     } catch (std::exception& e) {
100724       {
100725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100726       };
100727     } catch (Dali::DaliException e) {
100728       {
100729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100730       };
100731     } catch (...) {
100732       {
100733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100734       };
100735     }
100736   }
100737
100738   jresult = result;
100739   return jresult;
100740 }
100741
100742
100743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100744   float jresult ;
100745   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100746   float arg2 ;
100747   float arg3 ;
100748   float arg4 ;
100749   float arg5 ;
100750   Dali::Toolkit::ClampState *arg6 = 0 ;
100751   float result;
100752
100753   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100754   arg2 = (float)jarg2;
100755   arg3 = (float)jarg3;
100756   arg4 = (float)jarg4;
100757   arg5 = (float)jarg5;
100758   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100759   if (!arg6) {
100760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100761     return 0;
100762   }
100763   {
100764     try {
100765       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100766     } catch (std::out_of_range& e) {
100767       {
100768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100769       };
100770     } catch (std::exception& e) {
100771       {
100772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100773       };
100774     } catch (Dali::DaliException e) {
100775       {
100776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100777       };
100778     } catch (...) {
100779       {
100780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100781       };
100782     }
100783   }
100784
100785   jresult = result;
100786   return jresult;
100787 }
100788
100789
100790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100792
100793   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100794   {
100795     try {
100796       (*arg1)->Reference();
100797     } catch (std::out_of_range& e) {
100798       {
100799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100800       };
100801     } catch (std::exception& e) {
100802       {
100803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100804       };
100805     } catch (Dali::DaliException e) {
100806       {
100807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100808       };
100809     } catch (...) {
100810       {
100811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100812       };
100813     }
100814   }
100815
100816 }
100817
100818
100819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100820   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100821
100822   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100823   {
100824     try {
100825       (*arg1)->Unreference();
100826     } catch (std::out_of_range& e) {
100827       {
100828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100829       };
100830     } catch (std::exception& e) {
100831       {
100832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100833       };
100834     } catch (Dali::DaliException e) {
100835       {
100836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100837       };
100838     } catch (...) {
100839       {
100840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100841       };
100842     }
100843   }
100844
100845 }
100846
100847
100848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100849   int jresult ;
100850   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100851   int result;
100852
100853   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100854   {
100855     try {
100856       result = (int)(*arg1)->ReferenceCount();
100857     } catch (std::out_of_range& e) {
100858       {
100859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100860       };
100861     } catch (std::exception& e) {
100862       {
100863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100864       };
100865     } catch (Dali::DaliException e) {
100866       {
100867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100868       };
100869     } catch (...) {
100870       {
100871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100872       };
100873     }
100874   }
100875
100876   jresult = result;
100877   return jresult;
100878 }
100879
100880
100881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100882   unsigned int jresult ;
100883   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100884   bool result;
100885
100886   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100887   {
100888     try {
100889       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100890     } catch (std::out_of_range& e) {
100891       {
100892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100893       };
100894     } catch (std::exception& e) {
100895       {
100896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100897       };
100898     } catch (Dali::DaliException e) {
100899       {
100900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100901       };
100902     } catch (...) {
100903       {
100904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100905       };
100906     }
100907   }
100908
100909   jresult = result;
100910   return jresult;
100911 }
100912
100913
100914 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100915   unsigned long jresult ;
100916   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100917   std::size_t result;
100918
100919   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100920   {
100921     try {
100922       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100923     } catch (std::out_of_range& e) {
100924       {
100925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100926       };
100927     } catch (std::exception& e) {
100928       {
100929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100930       };
100931     } catch (Dali::DaliException e) {
100932       {
100933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100934       };
100935     } catch (...) {
100936       {
100937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100938       };
100939     }
100940   }
100941
100942   jresult = (unsigned long)result;
100943   return jresult;
100944 }
100945
100946
100947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100948   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100949   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100950
100951   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100952   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100953   {
100954     try {
100955       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100956     } catch (std::out_of_range& e) {
100957       {
100958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100959       };
100960     } catch (std::exception& e) {
100961       {
100962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100963       };
100964     } catch (Dali::DaliException e) {
100965       {
100966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100967       };
100968     } catch (...) {
100969       {
100970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100971       };
100972     }
100973   }
100974
100975 }
100976
100977
100978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100979   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100980   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100981
100982   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100983   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100984   {
100985     try {
100986       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100987     } catch (std::out_of_range& e) {
100988       {
100989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100990       };
100991     } catch (std::exception& e) {
100992       {
100993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100994       };
100995     } catch (Dali::DaliException e) {
100996       {
100997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100998       };
100999     } catch (...) {
101000       {
101001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101002       };
101003     }
101004   }
101005
101006 }
101007
101008
101009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
101010   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101011   Dali::Toolkit::Control arg2 ;
101012   Dali::Toolkit::Control *argp2 ;
101013
101014   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101015   argp2 = (Dali::Toolkit::Control *)jarg2;
101016   if (!argp2) {
101017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
101018     return ;
101019   }
101020   arg2 = *argp2;
101021   {
101022     try {
101023       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
101024     } catch (std::out_of_range& e) {
101025       {
101026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101027       };
101028     } catch (std::exception& e) {
101029       {
101030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101031       };
101032     } catch (Dali::DaliException e) {
101033       {
101034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101035       };
101036     } catch (...) {
101037       {
101038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101039       };
101040     }
101041   }
101042
101043 }
101044
101045
101046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
101047   void * jresult ;
101048   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
101049
101050   {
101051     try {
101052       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
101053     } catch (std::out_of_range& e) {
101054       {
101055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101056       };
101057     } catch (std::exception& e) {
101058       {
101059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101060       };
101061     } catch (Dali::DaliException e) {
101062       {
101063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101064       };
101065     } catch (...) {
101066       {
101067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101068       };
101069     }
101070   }
101071
101072   jresult = (void *)result;
101073   return jresult;
101074 }
101075
101076
101077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101078   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101079
101080   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101081   {
101082     try {
101083       delete arg1;
101084     } catch (std::out_of_range& e) {
101085       {
101086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101087       };
101088     } catch (std::exception& e) {
101089       {
101090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101091       };
101092     } catch (Dali::DaliException e) {
101093       {
101094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101095       };
101096     } catch (...) {
101097       {
101098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101099       };
101100     }
101101   }
101102
101103 }
101104
101105 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101106   Dali::RefObject *result = NULL;
101107
101108   if (arg1)
101109   {
101110     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101111   }
101112   return result;
101113 }
101114
101115 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101116     return (Dali::RefObject *)jarg1;
101117 }
101118
101119 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101120     return (Dali::SignalObserver *)jarg1;
101121 }
101122
101123 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101124     return (Dali::ConnectionTrackerInterface *)jarg1;
101125 }
101126
101127 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101128     return (Dali::BaseHandle *)jarg1;
101129 }
101130
101131 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101132     return (Dali::BaseHandle *)jarg1;
101133 }
101134
101135 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101136     return (Dali::BaseHandle *)jarg1;
101137 }
101138
101139 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101140     return (Dali::BaseHandle *)jarg1;
101141 }
101142
101143 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101144     return (Dali::BaseHandle *)jarg1;
101145 }
101146
101147 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101148     return (Dali::BaseHandle *)jarg1;
101149 }
101150
101151 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101152     return (Dali::BaseHandle *)jarg1;
101153 }
101154
101155 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101156     return (Dali::BaseHandle *)jarg1;
101157 }
101158
101159 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101160     return (Dali::BaseHandle *)jarg1;
101161 }
101162
101163 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101164     return (Dali::BaseHandle *)jarg1;
101165 }
101166
101167 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101168     return (Dali::BaseHandle *)jarg1;
101169 }
101170
101171 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101172     return (Dali::BaseHandle *)jarg1;
101173 }
101174
101175 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101176     return (Dali::BaseHandle *)jarg1;
101177 }
101178
101179 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101180     return (Dali::Handle *)jarg1;
101181 }
101182
101183 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101184     return (Dali::Handle *)jarg1;
101185 }
101186
101187 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101188     return (Dali::BaseHandle *)jarg1;
101189 }
101190
101191 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101192     return (Dali::BaseHandle *)jarg1;
101193 }
101194
101195 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101196     return (Dali::Handle *)jarg1;
101197 }
101198
101199 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101200     return (Dali::BaseHandle *)jarg1;
101201 }
101202
101203 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101204     return (Dali::Handle *)jarg1;
101205 }
101206
101207 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101208     return (Dali::GestureDetector *)jarg1;
101209 }
101210
101211 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101212     return (Dali::Gesture *)jarg1;
101213 }
101214
101215 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101216     return (Dali::Handle *)jarg1;
101217 }
101218
101219 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101220     return (Dali::Actor *)jarg1;
101221 }
101222
101223 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101224     return (Dali::BaseHandle *)jarg1;
101225 }
101226
101227 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101228     return (Dali::RefObject *)jarg1;
101229 }
101230
101231 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101232     return (Dali::Actor *)jarg1;
101233 }
101234
101235 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101236     return (Dali::GestureDetector *)jarg1;
101237 }
101238
101239 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101240     return (Dali::Gesture *)jarg1;
101241 }
101242
101243 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101244     return (Dali::GestureDetector *)jarg1;
101245 }
101246
101247 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101248     return (Dali::Gesture *)jarg1;
101249 }
101250
101251 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101252     return (Dali::GestureDetector *)jarg1;
101253 }
101254
101255 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101256     return (Dali::Gesture *)jarg1;
101257 }
101258
101259 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101260     return (Dali::BaseHandle *)jarg1;
101261 }
101262
101263 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101264     return (Dali::Handle *)jarg1;
101265 }
101266
101267 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101268     return (Dali::Handle *)jarg1;
101269 }
101270
101271 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101272     return (Dali::Handle *)jarg1;
101273 }
101274
101275 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101276     return (Dali::Image *)jarg1;
101277 }
101278
101279 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101280     return (Dali::Image *)jarg1;
101281 }
101282
101283 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101284     return (Dali::Image *)jarg1;
101285 }
101286
101287 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101288     return (Dali::RefObject *)jarg1;
101289 }
101290
101291 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101292     return (Dali::Image *)jarg1;
101293 }
101294
101295 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101296     return (Dali::Image *)jarg1;
101297 }
101298
101299 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101300     return (Dali::ResourceImage *)jarg1;
101301 }
101302
101303 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101304     return (Dali::Actor *)jarg1;
101305 }
101306
101307 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101308     return (Dali::BaseHandle *)jarg1;
101309 }
101310
101311 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101312     return (Dali::BaseHandle *)jarg1;
101313 }
101314
101315
101316 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101317     return (Dali::BaseHandle *)jarg1;
101318 }
101319
101320 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101321     return (Dali::BaseHandle *)jarg1;
101322 }
101323
101324 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101325     return (Dali::CustomActorImpl *)jarg1;
101326 }
101327
101328 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101329     return (Dali::CustomActor *)jarg1;
101330 }
101331
101332 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101333     return (Dali::BaseHandle *)jarg1;
101334 }
101335
101336 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101337     return (Dali::Toolkit::Control *)jarg1;
101338 }
101339
101340 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101341     return (Dali::Toolkit::Control *)jarg1;
101342 }
101343
101344 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101345     return (Dali::Toolkit::Button *)jarg1;
101346 }
101347
101348 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101349     return (Dali::Toolkit::Button *)jarg1;
101350 }
101351
101352 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101353     return (Dali::Toolkit::Button *)jarg1;
101354 }
101355
101356 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101357     return (Dali::Toolkit::Control *)jarg1;
101358 }
101359
101360 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101361     return (Dali::Toolkit::Control *)jarg1;
101362 }
101363
101364 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101365     return (Dali::Toolkit::Control *)jarg1;
101366 }
101367
101368 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101369     return (Dali::Toolkit::Control *)jarg1;
101370 }
101371
101372 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101373     return (Dali::Toolkit::Control *)jarg1;
101374 }
101375
101376 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101377     return (Dali::RefObject *)jarg1;
101378 }
101379
101380 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101381     return (Dali::Toolkit::Scrollable *)jarg1;
101382 }
101383
101384 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101385     return (Dali::BaseHandle *)jarg1;
101386 }
101387
101388 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101389     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101390 }
101391
101392 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101393     return (Dali::RefObject *)jarg1;
101394 }
101395
101396 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101397     return (Dali::Toolkit::Ruler *)jarg1;
101398 }
101399
101400 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101401     return (Dali::Toolkit::Ruler *)jarg1;
101402 }
101403
101404 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101405     return (Dali::Toolkit::Scrollable *)jarg1;
101406 }
101407
101408 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101409     return (Dali::Toolkit::Control *)jarg1;
101410 }
101411
101412
101413 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101414     return (Dali::Toolkit::Control *)jarg1;
101415 }
101416
101417 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101418     return (Dali::BaseHandle *)jarg1;
101419 }
101420
101421 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101422     return (Dali::BaseHandle *)jarg1;
101423 }
101424
101425 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101426     return (Dali::Toolkit::Control *)jarg1;
101427 }
101428
101429 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101430     return (Dali::Toolkit::Control *)jarg1;
101431 }
101432
101433 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101434     return (Dali::Toolkit::Control *)jarg1;
101435 }
101436
101437 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101438     return (Dali::Toolkit::Control *)jarg1;
101439 }
101440
101441 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101442     return (Dali::Toolkit::Control *)jarg1;
101443 }
101444
101445 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101446     return (Dali::Toolkit::Control *)jarg1;
101447 }
101448
101449 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101450     return (Dali::Toolkit::PageTurnView *)jarg1;
101451 }
101452
101453 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101454     return (Dali::Toolkit::PageTurnView *)jarg1;
101455 }
101456
101457 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101458     return (Dali::Toolkit::Button *)jarg1;
101459 }
101460
101461 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101462     return (Dali::BaseHandle *)jarg1;
101463 }
101464
101465 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101466     return (Dali::BaseHandle *)jarg1;
101467 }
101468
101469 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101470     return (Dali::BaseHandle *)jarg1;
101471 }
101472
101473 /*
101474  * Widget binding
101475  */
101476 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101477     return (Dali::BaseHandle *)jarg1;
101478 }
101479
101480 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101481     return (Dali::BaseObject *)jarg1;
101482 }
101483
101484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101485   void * jresult ;
101486   Dali::Widget result;
101487
101488   {
101489     try {
101490       result = Dali::Widget::New();
101491     } catch (std::out_of_range& e) {
101492       {
101493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101494       };
101495     } catch (std::exception& e) {
101496       {
101497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101498       };
101499     } catch (...) {
101500       {
101501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101502       };
101503     }
101504   }
101505   jresult = new Dali::Widget((const Dali::Widget &)result);
101506   return jresult;
101507 }
101508
101509
101510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101511   void * jresult ;
101512   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101513   Dali::Widget result;
101514
101515   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101516
101517   if (!arg1) {
101518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101519     return 0;
101520   }
101521   {
101522     try {
101523       jresult = new Dali::Widget(arg1);
101524     } catch (std::out_of_range& e) {
101525       {
101526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101527       };
101528     } catch (std::exception& e) {
101529       {
101530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101531       };
101532     } catch (...) {
101533       {
101534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101535       };
101536     }
101537   }
101538   return jresult;
101539 }
101540
101541
101542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101543   void * jresult ;
101544   Dali::Widget *result = 0 ;
101545
101546   {
101547     try {
101548       result = (Dali::Widget *)new Dali::Widget();
101549     } catch (std::out_of_range& e) {
101550       {
101551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101552       };
101553     } catch (std::exception& e) {
101554       {
101555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101556       };
101557     } catch (...) {
101558       {
101559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101560       };
101561     }
101562   }
101563   jresult = (void *)result;
101564   return jresult;
101565 }
101566
101567
101568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101569   void * jresult ;
101570   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101571   Dali::Widget *arg2 = 0 ;
101572   Dali::Widget *result = 0 ;
101573
101574   arg1 = (Dali::Widget *)jarg1;
101575   arg2 = (Dali::Widget *)jarg2;
101576   if (!arg2) {
101577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101578     return 0;
101579   }
101580   {
101581     try {
101582       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101583     } catch (std::out_of_range& e) {
101584       {
101585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101586       };
101587     } catch (std::exception& e) {
101588       {
101589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101590       };
101591     } catch (...) {
101592       {
101593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101594       };
101595     }
101596   }
101597   jresult = (void *)result;
101598   return jresult;
101599 }
101600
101601
101602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101603   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101604
101605   arg1 = (Dali::Widget *)jarg1;
101606   {
101607     try {
101608       delete arg1;
101609     } catch (std::out_of_range& e) {
101610       {
101611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101612       };
101613     } catch (std::exception& e) {
101614       {
101615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101616       };
101617     } catch (...) {
101618       {
101619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101620       };
101621     }
101622   }
101623 }
101624
101625
101626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101627   void * jresult ;
101628   SwigDirector_WidgetImpl* result;
101629   {
101630     try {
101631       result = new SwigDirector_WidgetImpl();
101632     } catch (std::out_of_range& e) {
101633       {
101634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101635       };
101636     } catch (std::exception& e) {
101637       {
101638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101639       };
101640     } catch (...) {
101641       {
101642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101643       };
101644     }
101645   }
101646   jresult = result;
101647   return jresult;
101648 }
101649
101650
101651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101652   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101653   std::string *arg2 = 0 ;
101654   Dali::Window arg3 ;
101655   Dali::Window *argp3 ;
101656
101657   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101658   if (!jarg2) {
101659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101660     return ;
101661   }
101662   std::string arg2_str(jarg2);
101663   arg2 = &arg2_str;
101664   argp3 = (Dali::Window *)jarg3;
101665   if (!argp3) {
101666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101667     return ;
101668   }
101669   arg3 = *argp3;
101670   {
101671     try {
101672       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101673     } catch (std::out_of_range& e) {
101674       {
101675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101676       };
101677     } catch (std::exception& e) {
101678       {
101679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101680       };
101681     } catch (...) {
101682       {
101683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101684       };
101685     }
101686   }
101687 }
101688
101689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101690   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101691   std::string *arg2 = 0 ;
101692   Dali::Window arg3 ;
101693   Dali::Window *argp3 ;
101694
101695   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101696   if (!jarg2) {
101697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101698     return ;
101699   }
101700   std::string arg2_str(jarg2);
101701   arg2 = &arg2_str;
101702   argp3 = (Dali::Window *)jarg3;
101703   if (!argp3) {
101704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101705     return ;
101706   }
101707   arg3 = *argp3;
101708   {
101709     try {
101710       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101711     } catch (std::out_of_range& e) {
101712       {
101713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101714       };
101715     } catch (std::exception& e) {
101716       {
101717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101718       };
101719     } catch (...) {
101720       {
101721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101722       };
101723     }
101724   }
101725 }
101726
101727
101728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101729   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101730   std::string *arg2 = 0 ;
101731   Dali::Widget::Termination arg3 ;
101732
101733   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101734   if (!jarg2) {
101735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101736     return ;
101737   }
101738   std::string arg2_str(jarg2);
101739   arg2 = &arg2_str;
101740   arg3 = (Dali::Widget::Termination)jarg3;
101741   {
101742     try {
101743       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101744     } catch (std::out_of_range& e) {
101745       {
101746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101747       };
101748     } catch (std::exception& e) {
101749       {
101750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101751       };
101752     } catch (...) {
101753       {
101754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101755       };
101756     }
101757   }
101758 }
101759
101760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101761   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101762   std::string *arg2 = 0 ;
101763   Dali::Widget::Termination arg3 ;
101764
101765   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101766   if (!jarg2) {
101767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101768     return ;
101769   }
101770   std::string arg2_str(jarg2);
101771   arg2 = &arg2_str;
101772   arg3 = (Dali::Widget::Termination)jarg3;
101773   {
101774     try {
101775       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101776     } catch (std::out_of_range& e) {
101777       {
101778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101779       };
101780     } catch (std::exception& e) {
101781       {
101782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101783       };
101784     } catch (...) {
101785       {
101786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101787       };
101788     }
101789   }
101790 }
101791
101792
101793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101794   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101795
101796   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101797   {
101798     try {
101799       (arg1)->OnPause();
101800     } catch (std::out_of_range& e) {
101801       {
101802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101803       };
101804     } catch (std::exception& e) {
101805       {
101806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101807       };
101808     } catch (...) {
101809       {
101810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101811       };
101812     }
101813   }
101814 }
101815
101816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101817   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101818
101819   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101820   {
101821     try {
101822       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101823     } catch (std::out_of_range& e) {
101824       {
101825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101826       };
101827     } catch (std::exception& e) {
101828       {
101829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101830       };
101831     } catch (...) {
101832       {
101833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101834       };
101835     }
101836   }
101837 }
101838
101839
101840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101841   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101842
101843   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101844   {
101845     try {
101846       (arg1)->OnResume();
101847     } catch (std::out_of_range& e) {
101848       {
101849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101850       };
101851     } catch (std::exception& e) {
101852       {
101853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101854       };
101855     } catch (...) {
101856       {
101857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101858       };
101859     }
101860   }
101861 }
101862
101863
101864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101865   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101866
101867   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101868   {
101869     try {
101870       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101871     } catch (std::out_of_range& e) {
101872       {
101873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101874       };
101875     } catch (std::exception& e) {
101876       {
101877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101878       };
101879     } catch (...) {
101880       {
101881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101882       };
101883     }
101884   }
101885 }
101886
101887
101888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101889   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101890   Dali::Window arg2 ;
101891   Dali::Window *argp2 ;
101892
101893   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101894   argp2 = (Dali::Window *)jarg2;
101895   if (!argp2) {
101896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101897     return ;
101898   }
101899   arg2 = *argp2;
101900   {
101901     try {
101902       (arg1)->OnResize(arg2);
101903     } catch (std::out_of_range& e) {
101904       {
101905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101906       };
101907     } catch (std::exception& e) {
101908       {
101909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101910       };
101911     } catch (...) {
101912       {
101913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101914       };
101915     }
101916   }
101917 }
101918
101919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101920   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101921   Dali::Window arg2 ;
101922   Dali::Window *argp2 ;
101923
101924   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101925   argp2 = (Dali::Window *)jarg2;
101926   if (!argp2) {
101927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101928     return ;
101929   }
101930   arg2 = *argp2;
101931   {
101932     try {
101933       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101934     } catch (std::out_of_range& e) {
101935       {
101936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101937       };
101938     } catch (std::exception& e) {
101939       {
101940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101941       };
101942     } catch (...) {
101943       {
101944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101945       };
101946     }
101947   }
101948 }
101949
101950
101951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101952   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101953   std::string *arg2 = 0 ;
101954   int arg3 ;
101955
101956   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101957   if (!jarg2) {
101958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101959     return ;
101960   }
101961   std::string arg2_str(jarg2);
101962   arg2 = &arg2_str;
101963   arg3 = (int)jarg3;
101964   {
101965     try {
101966       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101967     } catch (std::out_of_range& e) {
101968       {
101969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101970       };
101971     } catch (std::exception& e) {
101972       {
101973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101974       };
101975     } catch (...) {
101976       {
101977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101978       };
101979     }
101980   }
101981 }
101982
101983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101984   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101985   std::string *arg2 = 0 ;
101986   int arg3 ;
101987
101988   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101989   if (!jarg2) {
101990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101991     return ;
101992   }
101993   std::string arg2_str(jarg2);
101994   arg2 = &arg2_str;
101995   arg3 = (int)jarg3;
101996   {
101997     try {
101998       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101999     } catch (std::out_of_range& e) {
102000       {
102001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102002       };
102003     } catch (std::exception& e) {
102004       {
102005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102006       };
102007     } catch (...) {
102008       {
102009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102010       };
102011     }
102012   }
102013 }
102014
102015
102016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
102017   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102018   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102019   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102020
102021   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102022   arg2 = (Dali::SlotObserver *)jarg2;
102023   arg3 = (Dali::CallbackBase *)jarg3;
102024   {
102025     try {
102026       (arg1)->SignalConnected(arg2,arg3);
102027     } catch (std::out_of_range& e) {
102028       {
102029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102030       };
102031     } catch (std::exception& e) {
102032       {
102033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102034       };
102035     } catch (...) {
102036       {
102037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102038       };
102039     }
102040   }
102041 }
102042
102043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102044   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102045   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102046   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102047
102048   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102049   arg2 = (Dali::SlotObserver *)jarg2;
102050   arg3 = (Dali::CallbackBase *)jarg3;
102051   {
102052     try {
102053       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
102054     } catch (std::out_of_range& e) {
102055       {
102056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102057       };
102058     } catch (std::exception& e) {
102059       {
102060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102061       };
102062     } catch (...) {
102063       {
102064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102065       };
102066     }
102067   }
102068 }
102069
102070
102071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
102072   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102073   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102074   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102075
102076   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102077   arg2 = (Dali::SlotObserver *)jarg2;
102078   arg3 = (Dali::CallbackBase *)jarg3;
102079   {
102080     try {
102081       (arg1)->SignalDisconnected(arg2,arg3);
102082     } catch (std::out_of_range& e) {
102083       {
102084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102085       };
102086     } catch (std::exception& e) {
102087       {
102088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102089       };
102090     } catch (...) {
102091       {
102092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102093       };
102094     }
102095   }
102096 }
102097
102098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102099   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102100   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102101   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102102
102103   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102104   arg2 = (Dali::SlotObserver *)jarg2;
102105   arg3 = (Dali::CallbackBase *)jarg3;
102106   {
102107     try {
102108       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102109     } catch (std::out_of_range& e) {
102110       {
102111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102112       };
102113     } catch (std::exception& e) {
102114       {
102115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102116       };
102117     } catch (...) {
102118       {
102119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102120       };
102121     }
102122   }
102123 }
102124
102125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102126   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102127   std::string *arg2 = 0 ;
102128
102129   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102130   if (!jarg2) {
102131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102132     return ;
102133   }
102134   std::string arg2_str(jarg2);
102135   arg2 = &arg2_str;
102136   {
102137     try {
102138       (arg1)->SetContentInfo((std::string const &)*arg2);
102139     } catch (std::out_of_range& e) {
102140       {
102141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102142       };
102143     } catch (std::exception& e) {
102144       {
102145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102146       };
102147     } catch (...) {
102148       {
102149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102150       };
102151     }
102152   }
102153 }
102154
102155
102156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102157   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102158   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102159
102160   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102161   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102162   {
102163     try {
102164       (arg1)->SetImpl(arg2);
102165     } catch (std::out_of_range& e) {
102166       {
102167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102168       };
102169     } catch (std::exception& e) {
102170       {
102171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102172       };
102173     } catch (...) {
102174       {
102175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102176       };
102177     }
102178   }
102179 }
102180
102181 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) {
102182
102183   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102184   if (director) {
102185     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102186   }
102187 }
102188
102189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102190   void * jresult ;
102191   Dali::Widget *arg1 = 0 ;
102192   SwigDirector_WidgetImpl *result = 0 ;
102193
102194   arg1 = (Dali::Widget *)jarg1;
102195   if (!arg1) {
102196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102197     return 0;
102198   }
102199   {
102200     try {
102201       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*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
102217   jresult = (void *)result;
102218   return jresult;
102219 }
102220
102221
102222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102223   void * jresult ;
102224   int *arg1 = (int *) 0 ;
102225   char ***arg2 ;
102226   std::string *arg3 = 0 ;
102227   Dali::WidgetApplication result;
102228   {
102229     int index = 0;
102230     int length = 0;
102231     char *retPtr;
102232     char *nextPtr;
102233     argWidgetC = jarg1;
102234     argWidgetV = new char*[jarg1 + 1];
102235
102236     retPtr = strtok_r( jarg2, " ", &nextPtr);
102237     if( retPtr )
102238     {
102239       length = strlen(retPtr);
102240     }
102241     argWidgetV[index] = new char[length + 1];
102242     if( retPtr )
102243     {
102244       strncpy(argWidgetV[index], retPtr, length);
102245     }
102246     argWidgetV[index][length] = '\0';
102247     index++;
102248
102249     while (index < jarg1)
102250     {
102251       length = 0;
102252       retPtr = strtok_r(NULL, " ", &nextPtr);
102253       if( retPtr )
102254       {
102255         length = strlen(retPtr);
102256       }
102257       argWidgetV[index] = new char[length + 1];
102258       if( retPtr )
102259       {
102260         strncpy(argWidgetV[index], retPtr, length);
102261       }
102262       argWidgetV[index][length] = '\0';
102263       index++;
102264     }
102265
102266     argWidgetV[jarg1] = NULL;
102267     argWidgetC = jarg1;
102268
102269     arg1 = &argWidgetC;
102270     arg2 = &argWidgetV;
102271   }
102272
102273   if (!jarg3) {
102274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102275     return 0;
102276   }
102277   std::string arg3_str(jarg3);
102278   arg3 = &arg3_str;
102279   {
102280     try {
102281       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102282     } catch (std::out_of_range& e) {
102283       {
102284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102285       };
102286     } catch (std::exception& e) {
102287       {
102288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102289       };
102290     } catch (...) {
102291       {
102292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102293       };
102294     }
102295   }
102296   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102297
102298   return jresult;
102299 }
102300
102301
102302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102303   void * jresult ;
102304   Dali::WidgetApplication *result = 0 ;
102305
102306   {
102307     try {
102308       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102309     } catch (std::out_of_range& e) {
102310       {
102311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102312       };
102313     } catch (std::exception& e) {
102314       {
102315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102316       };
102317     } catch (...) {
102318       {
102319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102320       };
102321     }
102322   }
102323   jresult = (void *)result;
102324   return jresult;
102325 }
102326
102327
102328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102329   void * jresult ;
102330   Dali::WidgetApplication *arg1 = 0 ;
102331   Dali::WidgetApplication *result = 0 ;
102332
102333   arg1 = (Dali::WidgetApplication *)jarg1;
102334   if (!arg1) {
102335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102336     return 0;
102337   }
102338   {
102339     try {
102340       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102341     } catch (std::out_of_range& e) {
102342       {
102343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102344       };
102345     } catch (std::exception& e) {
102346       {
102347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102348       };
102349     } catch (...) {
102350       {
102351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102352       };
102353     }
102354   }
102355   jresult = (void *)result;
102356   return jresult;
102357 }
102358
102359
102360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102361   void * jresult ;
102362   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102363   Dali::WidgetApplication *arg2 = 0 ;
102364   Dali::WidgetApplication *result = 0 ;
102365
102366   arg1 = (Dali::WidgetApplication *)jarg1;
102367   arg2 = (Dali::WidgetApplication *)jarg2;
102368   if (!arg2) {
102369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102370     return 0;
102371   }
102372   {
102373     try {
102374       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102375     } catch (std::out_of_range& e) {
102376       {
102377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102378       };
102379     } catch (std::exception& e) {
102380       {
102381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102382       };
102383     } catch (...) {
102384       {
102385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102386       };
102387     }
102388   }
102389   jresult = (void *)result;
102390   return jresult;
102391 }
102392
102393
102394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102395   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102396
102397   arg1 = (Dali::WidgetApplication *)jarg1;
102398   {
102399     try {
102400       delete arg1;
102401       if( argWidgetV )
102402       {
102403         // free string data
102404         for( int i=0; i < argWidgetC+1; i++)
102405         {
102406           delete [] argWidgetV[i];
102407         }
102408         delete [] argWidgetV;
102409       }
102410     } catch (std::out_of_range& e) {
102411       {
102412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102413       };
102414     } catch (std::exception& e) {
102415       {
102416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102417       };
102418     } catch (...) {
102419       {
102420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102421       };
102422     }
102423   }
102424 }
102425
102426
102427 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102428 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102429
102430 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102431 {
102432   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102433   return *widget;
102434 }
102435
102436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102437   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102438   std::string *arg2 = 0 ;
102439
102440   arg1 = (Dali::WidgetApplication *)jarg1;
102441   if (!jarg2) {
102442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102443     return ;
102444   }
102445   std::string arg2_str(*jarg2);
102446   arg2 = &arg2_str;
102447
102448   if(!_CSharpCreateWidgetFunction)
102449   {
102450     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102451   }
102452
102453   {
102454     try {
102455       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102456     } catch (std::out_of_range& e) {
102457       {
102458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102459       };
102460     } catch (std::exception& e) {
102461       {
102462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102463       };
102464     } catch (...) {
102465       {
102466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102467       };
102468     }
102469   }
102470
102471   //Typemap argout in c++ file.
102472   //This will convert c++ string to c# string
102473   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102474 }
102475
102476
102477 //for PixelBuffer and ImageLoading
102478
102479 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102480     return (Dali::BaseHandle *)jarg1;
102481 }
102482
102483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102484   void * jresult ;
102485   unsigned int arg1 ;
102486   unsigned int arg2 ;
102487   Dali::Pixel::Format arg3 ;
102488   Dali::Devel::PixelBuffer result;
102489
102490   arg1 = (unsigned int)jarg1;
102491   arg2 = (unsigned int)jarg2;
102492   arg3 = (Dali::Pixel::Format)jarg3;
102493   {
102494     try {
102495       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102496     } catch (std::out_of_range& e) {
102497       {
102498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102499       };
102500     } catch (std::exception& e) {
102501       {
102502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102503       };
102504     } catch (...) {
102505       {
102506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102507       };
102508     }
102509   }
102510   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102511   return jresult;
102512 }
102513
102514
102515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102516   void * jresult ;
102517   Dali::Devel::PixelBuffer *result = 0 ;
102518
102519   {
102520     try {
102521       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102522     } catch (std::out_of_range& e) {
102523       {
102524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102525       };
102526     } catch (std::exception& e) {
102527       {
102528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102529       };
102530     } catch (...) {
102531       {
102532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102533       };
102534     }
102535   }
102536   jresult = (void *)result;
102537   return jresult;
102538 }
102539
102540
102541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102542   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102543
102544   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102545   {
102546     try {
102547       delete arg1;
102548     } catch (std::out_of_range& e) {
102549       {
102550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102551       };
102552     } catch (std::exception& e) {
102553       {
102554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102555       };
102556     } catch (...) {
102557       {
102558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102559       };
102560     }
102561   }
102562 }
102563
102564
102565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102566   void * jresult ;
102567   Dali::Devel::PixelBuffer *arg1 = 0 ;
102568   Dali::Devel::PixelBuffer *result = 0 ;
102569
102570   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102571   if (!arg1) {
102572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102573     return 0;
102574   }
102575   {
102576     try {
102577       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102578     } catch (std::out_of_range& e) {
102579       {
102580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102581       };
102582     } catch (std::exception& e) {
102583       {
102584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102585       };
102586     } catch (...) {
102587       {
102588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102589       };
102590     }
102591   }
102592   jresult = (void *)result;
102593   return jresult;
102594 }
102595
102596
102597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102598   void * jresult ;
102599   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102600   Dali::Devel::PixelBuffer *arg2 = 0 ;
102601   Dali::Devel::PixelBuffer *result = 0 ;
102602
102603   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102604   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102605   if (!arg2) {
102606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102607     return 0;
102608   }
102609   {
102610     try {
102611       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102612     } catch (std::out_of_range& e) {
102613       {
102614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102615       };
102616     } catch (std::exception& e) {
102617       {
102618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102619       };
102620     } catch (...) {
102621       {
102622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102623       };
102624     }
102625   }
102626   jresult = (void *)result;
102627   return jresult;
102628 }
102629
102630
102631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102632   void * jresult ;
102633   Dali::Devel::PixelBuffer *arg1 = 0 ;
102634   Dali::PixelData result;
102635
102636   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102637   if (!arg1) {
102638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102639     return 0;
102640   }
102641   {
102642     try {
102643       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102644     } catch (std::out_of_range& e) {
102645       {
102646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102647       };
102648     } catch (std::exception& e) {
102649       {
102650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102651       };
102652     } catch (...) {
102653       {
102654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102655       };
102656     }
102657   }
102658   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102659   return jresult;
102660 }
102661
102662
102663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102664   void * jresult ;
102665   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102666   Dali::PixelData result;
102667
102668   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102669   {
102670     try {
102671       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102672     } catch (std::out_of_range& e) {
102673       {
102674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102675       };
102676     } catch (std::exception& e) {
102677       {
102678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102679       };
102680     } catch (...) {
102681       {
102682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102683       };
102684     }
102685   }
102686   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102687   return jresult;
102688 }
102689
102690
102691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102692   void * jresult ;
102693   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102694   unsigned char *result = 0 ;
102695
102696   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102697   {
102698     try {
102699       result = (unsigned char *)(arg1)->GetBuffer();
102700     } catch (std::out_of_range& e) {
102701       {
102702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102703       };
102704     } catch (std::exception& e) {
102705       {
102706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102707       };
102708     } catch (...) {
102709       {
102710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102711       };
102712     }
102713   }
102714   jresult = (void *)result;
102715   return jresult;
102716 }
102717
102718
102719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102720   unsigned int jresult ;
102721   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102722   unsigned int result;
102723
102724   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102725   {
102726     try {
102727       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102728     } catch (std::out_of_range& e) {
102729       {
102730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102731       };
102732     } catch (std::exception& e) {
102733       {
102734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102735       };
102736     } catch (...) {
102737       {
102738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102739       };
102740     }
102741   }
102742   jresult = result;
102743   return jresult;
102744 }
102745
102746
102747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102748   unsigned int jresult ;
102749   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102750   unsigned int result;
102751
102752   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102753   {
102754     try {
102755       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102756     } catch (std::out_of_range& e) {
102757       {
102758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102759       };
102760     } catch (std::exception& e) {
102761       {
102762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102763       };
102764     } catch (...) {
102765       {
102766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102767       };
102768     }
102769   }
102770   jresult = result;
102771   return jresult;
102772 }
102773
102774
102775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102776   int jresult ;
102777   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102778   Dali::Pixel::Format result;
102779
102780   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102781   {
102782     try {
102783       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102784     } catch (std::out_of_range& e) {
102785       {
102786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102787       };
102788     } catch (std::exception& e) {
102789       {
102790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102791       };
102792     } catch (...) {
102793       {
102794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102795       };
102796     }
102797   }
102798   jresult = (int)result;
102799   return jresult;
102800 }
102801
102802
102803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102804   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102805   Dali::Devel::PixelBuffer arg2 ;
102806   float arg3 ;
102807   bool arg4 ;
102808   Dali::Devel::PixelBuffer *argp2 ;
102809
102810   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102811   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102812   if (!argp2) {
102813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102814     return ;
102815   }
102816   arg2 = *argp2;
102817   arg3 = (float)jarg3;
102818   arg4 = jarg4 ? true : false;
102819   {
102820     try {
102821       (arg1)->ApplyMask(arg2,arg3,arg4);
102822     } catch (std::out_of_range& e) {
102823       {
102824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102825       };
102826     } catch (std::exception& e) {
102827       {
102828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102829       };
102830     } catch (...) {
102831       {
102832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102833       };
102834     }
102835   }
102836 }
102837
102838
102839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102840   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102841   Dali::Devel::PixelBuffer arg2 ;
102842   float arg3 ;
102843   Dali::Devel::PixelBuffer *argp2 ;
102844
102845   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102846   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102847   if (!argp2) {
102848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102849     return ;
102850   }
102851   arg2 = *argp2;
102852   arg3 = (float)jarg3;
102853   {
102854     try {
102855       (arg1)->ApplyMask(arg2,arg3);
102856     } catch (std::out_of_range& e) {
102857       {
102858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102859       };
102860     } catch (std::exception& e) {
102861       {
102862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102863       };
102864     } catch (...) {
102865       {
102866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102867       };
102868     }
102869   }
102870 }
102871
102872
102873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102874   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102875   Dali::Devel::PixelBuffer arg2 ;
102876   Dali::Devel::PixelBuffer *argp2 ;
102877
102878   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102879   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102880   if (!argp2) {
102881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102882     return ;
102883   }
102884   arg2 = *argp2;
102885   {
102886     try {
102887       (arg1)->ApplyMask(arg2);
102888     } catch (std::out_of_range& e) {
102889       {
102890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102891       };
102892     } catch (std::exception& e) {
102893       {
102894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102895       };
102896     } catch (...) {
102897       {
102898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102899       };
102900     }
102901   }
102902 }
102903
102904
102905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102906   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102907   float arg2 ;
102908
102909   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102910   arg2 = (float)jarg2;
102911   {
102912     try {
102913       (arg1)->ApplyGaussianBlur(arg2);
102914     } catch (std::out_of_range& e) {
102915       {
102916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102917       };
102918     } catch (std::exception& e) {
102919       {
102920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102921       };
102922     } catch (...) {
102923       {
102924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102925       };
102926     }
102927   }
102928 }
102929
102930
102931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102932   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102933   uint16_t arg2 ;
102934   uint16_t arg3 ;
102935   uint16_t arg4 ;
102936   uint16_t arg5 ;
102937
102938   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102939   arg2 = (uint16_t)jarg2;
102940   arg3 = (uint16_t)jarg3;
102941   arg4 = (uint16_t)jarg4;
102942   arg5 = (uint16_t)jarg5;
102943   {
102944     try {
102945       (arg1)->Crop(arg2,arg3,arg4,arg5);
102946     } catch (std::out_of_range& e) {
102947       {
102948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102949       };
102950     } catch (std::exception& e) {
102951       {
102952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102953       };
102954     } catch (...) {
102955       {
102956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102957       };
102958     }
102959   }
102960 }
102961
102962
102963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102964   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102965   uint16_t arg2 ;
102966   uint16_t arg3 ;
102967
102968   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102969   arg2 = (uint16_t)jarg2;
102970   arg3 = (uint16_t)jarg3;
102971   {
102972     try {
102973       (arg1)->Resize(arg2,arg3);
102974     } catch (std::out_of_range& e) {
102975       {
102976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102977       };
102978     } catch (std::exception& e) {
102979       {
102980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102981       };
102982     } catch (...) {
102983       {
102984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102985       };
102986     }
102987   }
102988 }
102989
102990
102991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102992   void * jresult ;
102993   std::string *arg1 = 0 ;
102994   Dali::ImageDimensions arg2 ;
102995   Dali::FittingMode::Type arg3 ;
102996   Dali::SamplingMode::Type arg4 ;
102997   bool arg5 ;
102998   Dali::ImageDimensions *argp2 ;
102999   Dali::Devel::PixelBuffer result;
103000
103001   if (!jarg1) {
103002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103003     return 0;
103004   }
103005   std::string arg1_str(jarg1);
103006   arg1 = &arg1_str;
103007   argp2 = (Dali::ImageDimensions *)jarg2;
103008   if (!argp2) {
103009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103010     return 0;
103011   }
103012   arg2 = *argp2;
103013   arg3 = (Dali::FittingMode::Type)jarg3;
103014   arg4 = (Dali::SamplingMode::Type)jarg4;
103015   arg5 = jarg5 ? true : false;
103016   {
103017     try {
103018       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103019     } catch (std::out_of_range& e) {
103020       {
103021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103022       };
103023     } catch (std::exception& e) {
103024       {
103025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103026       };
103027     } catch (...) {
103028       {
103029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103030       };
103031     }
103032   }
103033   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103034
103035   return jresult;
103036 }
103037
103038
103039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103040   void * jresult ;
103041   std::string *arg1 = 0 ;
103042   Dali::ImageDimensions arg2 ;
103043   Dali::FittingMode::Type arg3 ;
103044   Dali::SamplingMode::Type arg4 ;
103045   Dali::ImageDimensions *argp2 ;
103046   Dali::Devel::PixelBuffer result;
103047
103048   if (!jarg1) {
103049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103050     return 0;
103051   }
103052   std::string arg1_str(jarg1);
103053   arg1 = &arg1_str;
103054   argp2 = (Dali::ImageDimensions *)jarg2;
103055   if (!argp2) {
103056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103057     return 0;
103058   }
103059   arg2 = *argp2;
103060   arg3 = (Dali::FittingMode::Type)jarg3;
103061   arg4 = (Dali::SamplingMode::Type)jarg4;
103062   {
103063     try {
103064       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
103065     } catch (std::out_of_range& e) {
103066       {
103067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103068       };
103069     } catch (std::exception& e) {
103070       {
103071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103072       };
103073     } catch (...) {
103074       {
103075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103076       };
103077     }
103078   }
103079   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103080
103081   return jresult;
103082 }
103083
103084
103085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103086   void * jresult ;
103087   std::string *arg1 = 0 ;
103088   Dali::ImageDimensions arg2 ;
103089   Dali::FittingMode::Type arg3 ;
103090   Dali::ImageDimensions *argp2 ;
103091   Dali::Devel::PixelBuffer result;
103092
103093   if (!jarg1) {
103094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103095     return 0;
103096   }
103097   std::string arg1_str(jarg1);
103098   arg1 = &arg1_str;
103099   argp2 = (Dali::ImageDimensions *)jarg2;
103100   if (!argp2) {
103101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103102     return 0;
103103   }
103104   arg2 = *argp2;
103105   arg3 = (Dali::FittingMode::Type)jarg3;
103106   {
103107     try {
103108       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103109     } catch (std::out_of_range& e) {
103110       {
103111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103112       };
103113     } catch (std::exception& e) {
103114       {
103115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103116       };
103117     } catch (...) {
103118       {
103119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103120       };
103121     }
103122   }
103123   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103124
103125   return jresult;
103126 }
103127
103128
103129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103130   void * jresult ;
103131   std::string *arg1 = 0 ;
103132   Dali::ImageDimensions arg2 ;
103133   Dali::ImageDimensions *argp2 ;
103134   Dali::Devel::PixelBuffer result;
103135
103136   if (!jarg1) {
103137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103138     return 0;
103139   }
103140   std::string arg1_str(jarg1);
103141   arg1 = &arg1_str;
103142   argp2 = (Dali::ImageDimensions *)jarg2;
103143   if (!argp2) {
103144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103145     return 0;
103146   }
103147   arg2 = *argp2;
103148   {
103149     try {
103150       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103151     } catch (std::out_of_range& e) {
103152       {
103153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103154       };
103155     } catch (std::exception& e) {
103156       {
103157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103158       };
103159     } catch (...) {
103160       {
103161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103162       };
103163     }
103164   }
103165   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103166
103167   return jresult;
103168 }
103169
103170
103171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103172   void * jresult ;
103173   std::string *arg1 = 0 ;
103174   Dali::Devel::PixelBuffer result;
103175
103176   if (!jarg1) {
103177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103178     return 0;
103179   }
103180   std::string arg1_str(jarg1);
103181   arg1 = &arg1_str;
103182   {
103183     try {
103184       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103185     } catch (std::out_of_range& e) {
103186       {
103187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103188       };
103189     } catch (std::exception& e) {
103190       {
103191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103192       };
103193     } catch (...) {
103194       {
103195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103196       };
103197     }
103198   }
103199   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103200
103201   return jresult;
103202 }
103203
103204
103205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103206   void * jresult ;
103207   std::string *arg1 = 0 ;
103208   Dali::ImageDimensions arg2 ;
103209   Dali::FittingMode::Type arg3 ;
103210   Dali::SamplingMode::Type arg4 ;
103211   bool arg5 ;
103212   Dali::ImageDimensions *argp2 ;
103213   Dali::ImageDimensions result;
103214
103215   if (!jarg1) {
103216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103217     return 0;
103218   }
103219   std::string arg1_str(jarg1);
103220   arg1 = &arg1_str;
103221   argp2 = (Dali::ImageDimensions *)jarg2;
103222   if (!argp2) {
103223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103224     return 0;
103225   }
103226   arg2 = *argp2;
103227   arg3 = (Dali::FittingMode::Type)jarg3;
103228   arg4 = (Dali::SamplingMode::Type)jarg4;
103229   arg5 = jarg5 ? true : false;
103230   {
103231     try {
103232       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103233     } catch (std::out_of_range& e) {
103234       {
103235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103236       };
103237     } catch (std::exception& e) {
103238       {
103239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103240       };
103241     } catch (...) {
103242       {
103243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103244       };
103245     }
103246   }
103247   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103248
103249   return jresult;
103250 }
103251
103252
103253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103254   void * jresult ;
103255   std::string *arg1 = 0 ;
103256   Dali::ImageDimensions arg2 ;
103257   Dali::FittingMode::Type arg3 ;
103258   Dali::SamplingMode::Type arg4 ;
103259   Dali::ImageDimensions *argp2 ;
103260   Dali::ImageDimensions result;
103261
103262   if (!jarg1) {
103263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103264     return 0;
103265   }
103266   std::string arg1_str(jarg1);
103267   arg1 = &arg1_str;
103268   argp2 = (Dali::ImageDimensions *)jarg2;
103269   if (!argp2) {
103270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103271     return 0;
103272   }
103273   arg2 = *argp2;
103274   arg3 = (Dali::FittingMode::Type)jarg3;
103275   arg4 = (Dali::SamplingMode::Type)jarg4;
103276   {
103277     try {
103278       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103279     } catch (std::out_of_range& e) {
103280       {
103281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103282       };
103283     } catch (std::exception& e) {
103284       {
103285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103286       };
103287     } catch (...) {
103288       {
103289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103290       };
103291     }
103292   }
103293   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103294
103295   return jresult;
103296 }
103297
103298
103299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103300   void * jresult ;
103301   std::string *arg1 = 0 ;
103302   Dali::ImageDimensions arg2 ;
103303   Dali::FittingMode::Type arg3 ;
103304   Dali::ImageDimensions *argp2 ;
103305   Dali::ImageDimensions result;
103306
103307   if (!jarg1) {
103308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103309     return 0;
103310   }
103311   std::string arg1_str(jarg1);
103312   arg1 = &arg1_str;
103313   argp2 = (Dali::ImageDimensions *)jarg2;
103314   if (!argp2) {
103315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103316     return 0;
103317   }
103318   arg2 = *argp2;
103319   arg3 = (Dali::FittingMode::Type)jarg3;
103320   {
103321     try {
103322       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103323     } catch (std::out_of_range& e) {
103324       {
103325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103326       };
103327     } catch (std::exception& e) {
103328       {
103329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103330       };
103331     } catch (...) {
103332       {
103333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103334       };
103335     }
103336   }
103337   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103338
103339   return jresult;
103340 }
103341
103342
103343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103344   void * jresult ;
103345   std::string *arg1 = 0 ;
103346   Dali::ImageDimensions arg2 ;
103347   Dali::ImageDimensions *argp2 ;
103348   Dali::ImageDimensions result;
103349
103350   if (!jarg1) {
103351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103352     return 0;
103353   }
103354   std::string arg1_str(jarg1);
103355   arg1 = &arg1_str;
103356   argp2 = (Dali::ImageDimensions *)jarg2;
103357   if (!argp2) {
103358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103359     return 0;
103360   }
103361   arg2 = *argp2;
103362   {
103363     try {
103364       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103365     } catch (std::out_of_range& e) {
103366       {
103367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103368       };
103369     } catch (std::exception& e) {
103370       {
103371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103372       };
103373     } catch (...) {
103374       {
103375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103376       };
103377     }
103378   }
103379   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103380
103381   return jresult;
103382 }
103383
103384
103385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103386   void * jresult ;
103387   std::string *arg1 = 0 ;
103388   Dali::ImageDimensions result;
103389
103390   if (!jarg1) {
103391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103392     return 0;
103393   }
103394   std::string arg1_str(jarg1);
103395   arg1 = &arg1_str;
103396   {
103397     try {
103398       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103399     } catch (std::out_of_range& e) {
103400       {
103401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103402       };
103403     } catch (std::exception& e) {
103404       {
103405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103406       };
103407     } catch (...) {
103408       {
103409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103410       };
103411     }
103412   }
103413   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103414
103415   return jresult;
103416 }
103417
103418
103419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103420   void * jresult ;
103421   std::string *arg1 = 0 ;
103422   Dali::ImageDimensions arg2 ;
103423   Dali::FittingMode::Type arg3 ;
103424   Dali::SamplingMode::Type arg4 ;
103425   bool arg5 ;
103426   Dali::ImageDimensions *argp2 ;
103427   Dali::Devel::PixelBuffer result;
103428
103429   if (!jarg1) {
103430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103431     return 0;
103432   }
103433   std::string arg1_str(jarg1);
103434   arg1 = &arg1_str;
103435   argp2 = (Dali::ImageDimensions *)jarg2;
103436   if (!argp2) {
103437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103438     return 0;
103439   }
103440   arg2 = *argp2;
103441   arg3 = (Dali::FittingMode::Type)jarg3;
103442   arg4 = (Dali::SamplingMode::Type)jarg4;
103443   arg5 = jarg5 ? true : false;
103444   {
103445     try {
103446       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103447     } catch (std::out_of_range& e) {
103448       {
103449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103450       };
103451     } catch (std::exception& e) {
103452       {
103453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103454       };
103455     } catch (...) {
103456       {
103457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103458       };
103459     }
103460   }
103461   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103462
103463   return jresult;
103464 }
103465
103466
103467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103468   void * jresult ;
103469   std::string *arg1 = 0 ;
103470   Dali::ImageDimensions arg2 ;
103471   Dali::FittingMode::Type arg3 ;
103472   Dali::SamplingMode::Type arg4 ;
103473   Dali::ImageDimensions *argp2 ;
103474   Dali::Devel::PixelBuffer result;
103475
103476   if (!jarg1) {
103477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103478     return 0;
103479   }
103480   std::string arg1_str(jarg1);
103481   arg1 = &arg1_str;
103482   argp2 = (Dali::ImageDimensions *)jarg2;
103483   if (!argp2) {
103484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103485     return 0;
103486   }
103487   arg2 = *argp2;
103488   arg3 = (Dali::FittingMode::Type)jarg3;
103489   arg4 = (Dali::SamplingMode::Type)jarg4;
103490   {
103491     try {
103492       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103493     } catch (std::out_of_range& e) {
103494       {
103495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103496       };
103497     } catch (std::exception& e) {
103498       {
103499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103500       };
103501     } catch (...) {
103502       {
103503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103504       };
103505     }
103506   }
103507   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103508
103509   return jresult;
103510 }
103511
103512
103513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103514   void * jresult ;
103515   std::string *arg1 = 0 ;
103516   Dali::ImageDimensions arg2 ;
103517   Dali::FittingMode::Type arg3 ;
103518   Dali::ImageDimensions *argp2 ;
103519   Dali::Devel::PixelBuffer result;
103520
103521   if (!jarg1) {
103522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103523     return 0;
103524   }
103525   std::string arg1_str(jarg1);
103526   arg1 = &arg1_str;
103527   argp2 = (Dali::ImageDimensions *)jarg2;
103528   if (!argp2) {
103529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103530     return 0;
103531   }
103532   arg2 = *argp2;
103533   arg3 = (Dali::FittingMode::Type)jarg3;
103534   {
103535     try {
103536       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103537     } catch (std::out_of_range& e) {
103538       {
103539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103540       };
103541     } catch (std::exception& e) {
103542       {
103543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103544       };
103545     } catch (...) {
103546       {
103547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103548       };
103549     }
103550   }
103551   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103552
103553   return jresult;
103554 }
103555
103556
103557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103558   void * jresult ;
103559   std::string *arg1 = 0 ;
103560   Dali::ImageDimensions arg2 ;
103561   Dali::ImageDimensions *argp2 ;
103562   Dali::Devel::PixelBuffer result;
103563
103564   if (!jarg1) {
103565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103566     return 0;
103567   }
103568   std::string arg1_str(jarg1);
103569   arg1 = &arg1_str;
103570   argp2 = (Dali::ImageDimensions *)jarg2;
103571   if (!argp2) {
103572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103573     return 0;
103574   }
103575   arg2 = *argp2;
103576   {
103577     try {
103578       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103579     } catch (std::out_of_range& e) {
103580       {
103581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103582       };
103583     } catch (std::exception& e) {
103584       {
103585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103586       };
103587     } catch (...) {
103588       {
103589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103590       };
103591     }
103592   }
103593   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103594
103595   return jresult;
103596 }
103597
103598
103599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103600   void * jresult ;
103601   std::string *arg1 = 0 ;
103602   Dali::Devel::PixelBuffer result;
103603
103604   if (!jarg1) {
103605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103606     return 0;
103607   }
103608   std::string arg1_str(jarg1);
103609   arg1 = &arg1_str;
103610   {
103611     try {
103612       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103613     } catch (std::out_of_range& e) {
103614       {
103615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103616       };
103617     } catch (std::exception& e) {
103618       {
103619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103620       };
103621     } catch (...) {
103622       {
103623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103624       };
103625     }
103626   }
103627   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103628
103629   return jresult;
103630 }
103631
103632
103633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
103634   void * jresult ;
103635   Dali::Toolkit::WebView result;
103636
103637   {
103638     try {
103639       result = Dali::Toolkit::WebView::New();
103640     } catch (std::out_of_range& e) {
103641       {
103642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103643       };
103644     } catch (std::exception& e) {
103645       {
103646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103647       };
103648     } catch (Dali::DaliException e) {
103649       {
103650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103651       };
103652     } catch (...) {
103653       {
103654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103655       };
103656     }
103657   }
103658   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103659   return jresult;
103660 }
103661
103662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
103663   void * jresult ;
103664   Dali::Toolkit::WebView result;
103665
103666   std::string *arg1;
103667   std::string *arg2;
103668
103669   if (!jarg1) {
103670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
103671     return 0;
103672   }
103673   if (!jarg2) {
103674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
103675     return 0;
103676   }
103677
103678   std::string jarg1_str = std::string(jarg1);
103679   std::string jarg2_str = std::string(jarg2);
103680
103681   arg1 = &jarg1_str;
103682   arg2 = &jarg2_str;
103683
103684   {
103685     try {
103686       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
103687     } catch (std::out_of_range& e) {
103688       {
103689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103690       };
103691     } catch (std::exception& e) {
103692       {
103693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103694       };
103695     } catch (Dali::DaliException e) {
103696       {
103697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103698       };
103699     } catch (...) {
103700       {
103701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103702       };
103703     }
103704   }
103705   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103706   return jresult;
103707 }
103708
103709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103710   void * jresult ;
103711   Dali::Toolkit::WebView *arg1 = 0 ;
103712   Dali::Toolkit::WebView *result = 0 ;
103713
103714   arg1 = (Dali::Toolkit::WebView *)jarg1;
103715   if (!arg1) {
103716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103717     return 0;
103718   }
103719   {
103720     try {
103721       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103722     } catch (std::out_of_range& e) {
103723       {
103724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103725       };
103726     } catch (std::exception& e) {
103727       {
103728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103729       };
103730     } catch (Dali::DaliException e) {
103731       {
103732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103733       };
103734     } catch (...) {
103735       {
103736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103737       };
103738     }
103739   }
103740   jresult = (void *)result;
103741   return jresult;
103742 }
103743
103744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103745   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103746   arg1 = (Dali::Toolkit::WebView *)jarg1;
103747   {
103748     try {
103749       delete arg1;
103750     } catch (std::out_of_range& e) {
103751       {
103752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103753       };
103754     } catch (std::exception& e) {
103755       {
103756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103757       };
103758     } catch (Dali::DaliException e) {
103759       {
103760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103761       };
103762     } catch (...) {
103763       {
103764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103765       };
103766     }
103767   }
103768 }
103769
103770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103771   void * jresult ;
103772   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103773   Dali::Toolkit::WebView *arg2 = 0 ;
103774   Dali::Toolkit::WebView *result = 0 ;
103775
103776   arg1 = (Dali::Toolkit::WebView *)jarg1;
103777   arg2 = (Dali::Toolkit::WebView *)jarg2;
103778   if (!arg2) {
103779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103780     return 0;
103781   }
103782   {
103783     try {
103784       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103785     } catch (std::out_of_range& e) {
103786       {
103787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103788       };
103789     } catch (std::exception& e) {
103790       {
103791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103792       };
103793     } catch (Dali::DaliException e) {
103794       {
103795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103796       };
103797     } catch (...) {
103798       {
103799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103800       };
103801     }
103802   }
103803   jresult = (void *)result;
103804   return jresult;
103805 }
103806
103807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103808   void * jresult ;
103809   Dali::BaseHandle arg1 ;
103810   Dali::BaseHandle *argp1 ;
103811   Dali::Toolkit::WebView result;
103812
103813   argp1 = (Dali::BaseHandle *)jarg1;
103814   if (!argp1) {
103815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103816     return 0;
103817   }
103818   arg1 = *argp1;
103819   {
103820     try {
103821       result = Dali::Toolkit::WebView::DownCast(arg1);
103822     } catch (std::out_of_range& e) {
103823       {
103824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103825       };
103826     } catch (std::exception& e) {
103827       {
103828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103829       };
103830     } catch (Dali::DaliException e) {
103831       {
103832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103833       };
103834     } catch (...) {
103835       {
103836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103837       };
103838     }
103839   }
103840   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103841   return jresult;
103842 }
103843
103844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103845   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103846   std::string *arg2;
103847
103848   arg1 = (Dali::Toolkit::WebView *)jarg1;
103849
103850   if (!jarg2) {
103851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103852     return;
103853   }
103854
103855   std::string jarg2str = std::string(jarg2);
103856   arg2 = &jarg2str;
103857   {
103858     try {
103859       (arg1)->LoadUrl((std::string const &)*arg2);
103860     } catch (std::out_of_range& e) {
103861       {
103862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103863       };
103864     } catch (std::exception& e) {
103865       {
103866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103867       };
103868     } catch (Dali::DaliException e) {
103869       {
103870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103871       };
103872     } catch (...) {
103873       {
103874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103875       };
103876     }
103877   }
103878 }
103879
103880 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WebView_GetUrl(void * jarg1) {
103881   char * jresult ;
103882   std::string result;
103883
103884   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103885
103886   arg1 = (Dali::Toolkit::WebView *)jarg1;
103887   {
103888     try {
103889       result = arg1->GetUrl();
103890     } catch (std::out_of_range& e) {
103891       {
103892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103893       };
103894     } catch (std::exception& e) {
103895       {
103896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103897       };
103898     } catch (Dali::DaliException e) {
103899       {
103900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103901       };
103902     } catch (...) {
103903       {
103904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103905       };
103906     }
103907   }
103908
103909   jresult = SWIG_csharp_string_callback((&result)->c_str());
103910   return jresult;
103911 }
103912
103913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103914   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103915   std::string *arg2;
103916
103917   arg1 = (Dali::Toolkit::WebView *)jarg1;
103918   if (!jarg2) {
103919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103920     return;
103921   }
103922   std::string jarg2str = std::string(jarg2);
103923   arg2 = &jarg2str;
103924   {
103925     try {
103926       (arg1)->LoadHTMLString((std::string const &)*arg2);
103927     } catch (std::out_of_range& e) {
103928       {
103929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103930       };
103931     } catch (std::exception& e) {
103932       {
103933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103934       };
103935     } catch (Dali::DaliException e) {
103936       {
103937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103938       };
103939     } catch (...) {
103940       {
103941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103942       };
103943     }
103944   }
103945 }
103946
103947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103948   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103949
103950   arg1 = (Dali::Toolkit::WebView *)jarg1;
103951   {
103952     try {
103953       (arg1)->Reload();
103954     } catch (std::out_of_range& e) {
103955       {
103956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103957       };
103958     } catch (std::exception& e) {
103959       {
103960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103961       };
103962     } catch (Dali::DaliException e) {
103963       {
103964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103965       };
103966     } catch (...) {
103967       {
103968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103969       };
103970     }
103971   }
103972 }
103973
103974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103975   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103976
103977   arg1 = (Dali::Toolkit::WebView *)jarg1;
103978   {
103979     try {
103980       (arg1)->StopLoading();
103981     } catch (std::out_of_range& e) {
103982       {
103983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103984       };
103985     } catch (std::exception& e) {
103986       {
103987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103988       };
103989     } catch (Dali::DaliException e) {
103990       {
103991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103992       };
103993     } catch (...) {
103994       {
103995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103996       };
103997     }
103998   }
103999 }
104000
104001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
104002   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104003
104004   arg1 = (Dali::Toolkit::WebView *)jarg1;
104005   {
104006     try {
104007       (arg1)->GoBack();
104008     } catch (std::out_of_range& e) {
104009       {
104010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104011       };
104012     } catch (std::exception& e) {
104013       {
104014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104015       };
104016     } catch (Dali::DaliException e) {
104017       {
104018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104019       };
104020     } catch (...) {
104021       {
104022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104023       };
104024     }
104025   }
104026 }
104027
104028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
104029   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104030
104031   arg1 = (Dali::Toolkit::WebView *)jarg1;
104032   {
104033     try {
104034       (arg1)->GoForward();
104035     } catch (std::out_of_range& e) {
104036       {
104037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104038       };
104039     } catch (std::exception& e) {
104040       {
104041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104042       };
104043     } catch (Dali::DaliException e) {
104044       {
104045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104046       };
104047     } catch (...) {
104048       {
104049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104050       };
104051     }
104052   }
104053 }
104054
104055 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
104056   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104057   bool ret;
104058
104059   arg1 = (Dali::Toolkit::WebView *)jarg1;
104060   {
104061     try {
104062       ret = (arg1)->CanGoBack();
104063     } catch (std::out_of_range& e) {
104064       {
104065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
104066       };
104067     } catch (std::exception& e) {
104068       {
104069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
104070       };
104071     } catch (Dali::DaliException e) {
104072       {
104073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
104074       };
104075     } catch (...) {
104076       {
104077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
104078       };
104079     }
104080   }
104081   return ret;
104082 }
104083
104084 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
104085   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104086   bool ret;
104087
104088   arg1 = (Dali::Toolkit::WebView *)jarg1;
104089   {
104090     try {
104091       ret = (arg1)->CanGoForward();
104092     } catch (std::out_of_range& e) {
104093       {
104094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
104095       };
104096     } catch (std::exception& e) {
104097       {
104098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
104099       };
104100     } catch (Dali::DaliException e) {
104101       {
104102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
104103       };
104104     } catch (...) {
104105       {
104106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
104107       };
104108     }
104109   }
104110   return ret;
104111 }
104112
104113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2) {
104114   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104115   std::string *arg2;
104116
104117   arg1 = (Dali::Toolkit::WebView *)jarg1;
104118   if (!jarg2) {
104119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
104120     return;
104121   }
104122   std::string jarg2_str = std::string(jarg2);
104123   arg2 = &jarg2_str;
104124   {
104125     try {
104126       (arg1)->EvaluateJavaScript((std::string const &)*arg2);
104127     } catch (std::out_of_range& e) {
104128       {
104129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104130       };
104131     } catch (std::exception& e) {
104132       {
104133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104134       };
104135     } catch (Dali::DaliException e) {
104136       {
104137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104138       };
104139     } catch (...) {
104140       {
104141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104142       };
104143     }
104144   }
104145 }
104146
104147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
104148   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104149
104150   arg1 = (Dali::Toolkit::WebView *)jarg1;
104151   {
104152     try {
104153       (arg1)->ClearHistory();
104154     } catch (std::out_of_range& e) {
104155       {
104156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104157       };
104158     } catch (std::exception& e) {
104159       {
104160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104161       };
104162     } catch (Dali::DaliException e) {
104163       {
104164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104165       };
104166     } catch (...) {
104167       {
104168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104169       };
104170     }
104171   }
104172 }
104173
104174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
104175   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104176
104177   arg1 = (Dali::Toolkit::WebView *)jarg1;
104178   {
104179     try {
104180       (arg1)->ClearCache();
104181     } catch (std::out_of_range& e) {
104182       {
104183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104184       };
104185     } catch (std::exception& e) {
104186       {
104187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104188       };
104189     } catch (Dali::DaliException e) {
104190       {
104191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104192       };
104193     } catch (...) {
104194       {
104195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104196       };
104197     }
104198   }
104199 }
104200
104201 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
104202     return (Dali::Toolkit::Control *)jarg1;
104203 }
104204
104205
104206 // Proxy class of WebViewSignal.
104207 // WebViewSignal has an argument of std::string type which is not supported at C# side.
104208 // The purpose of this class is to convert signal argument of string type safely.
104209 class WebViewSignalProxy : public ConnectionTracker
104210 {
104211 public:
104212   typedef Dali::Signal< void(Dali::Toolkit::WebView, const std::string&) > OriginalSignalType;
104213   typedef Dali::Signal< void(Dali::Toolkit::WebView, char*) > ProxySignalType;
104214   typedef void (*CallbackType)(Dali::Toolkit::WebView, char *);
104215
104216   WebViewSignalProxy(OriginalSignalType* signal)
104217     : mSignalPtr(signal)
104218   {
104219   }
104220
104221   void Connect(CallbackType csharpCallback)
104222   {
104223     if (mSignalPtr->Empty())
104224     {
104225       mSignalPtr->Connect(this, &WebViewSignalProxy::OnEmit);
104226     }
104227     mProxySignal.Connect(csharpCallback);
104228   }
104229
104230   void Disconnect(CallbackType csharpCallback)
104231   {
104232     mProxySignal.Disconnect(csharpCallback);
104233     if (mProxySignal.Empty())
104234     {
104235       mSignalPtr->Disconnect(this, &WebViewSignalProxy::OnEmit);
104236     }
104237   }
104238
104239   bool Empty()
104240   {
104241     return mProxySignal.Empty();
104242   }
104243
104244   std::size_t GetConnectionCount()
104245   {
104246     return mProxySignal.GetConnectionCount();
104247   }
104248
104249   void Emit(Dali::Toolkit::WebView& webview, char* url)
104250   {
104251     if (!mProxySignal.Empty())
104252     {
104253       mProxySignal.Emit(webview, url);
104254     }
104255   }
104256
104257   void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
104258   {
104259     // Safe string conversion
104260     mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
104261   }
104262
104263 private:
104264   OriginalSignalType* mSignalPtr;
104265   ProxySignalType mProxySignal;
104266 };
104267
104268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadStarted(void * jarg1) {
104269   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
104270   WebViewSignalProxy* result = NULL;
104271   {
104272     try {
104273       result = new WebViewSignalProxy(&webview->PageLoadStartedSignal());
104274     } catch (std::out_of_range& e) {
104275       {
104276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104277       };
104278     } catch (std::exception& e) {
104279       {
104280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104281       };
104282     } catch (Dali::DaliException e) {
104283       {
104284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104285       };
104286     } catch (...) {
104287       {
104288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104289       };
104290     }
104291   }
104292   return (void*) result;
104293 }
104294
104295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadFinished(void * jarg1) {
104296   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
104297   WebViewSignalProxy* result = NULL;
104298   {
104299     try {
104300       result = new WebViewSignalProxy(&webview->PageLoadFinishedSignal());
104301     } catch (std::out_of_range& e) {
104302       {
104303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104304       };
104305     } catch (std::exception& e) {
104306       {
104307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104308       };
104309     } catch (Dali::DaliException e) {
104310       {
104311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104312       };
104313     } catch (...) {
104314       {
104315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104316       };
104317     }
104318   }
104319   return (void*) result;
104320 }
104321
104322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewSignalProxy(void * jarg1)
104323 {
104324   WebViewSignalProxy* object = (WebViewSignalProxy*) jarg1;
104325   {
104326     try {
104327       delete object;
104328     } catch (std::out_of_range& e) {
104329       {
104330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104331       };
104332     } catch (std::exception& e) {
104333       {
104334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104335       };
104336     } catch (Dali::DaliException e) {
104337       {
104338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104339       };
104340     } catch (...) {
104341       {
104342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104343       };
104344     }
104345   }
104346 }
104347
104348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Empty(void * jarg1)
104349 {
104350   bool result;
104351   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104352   {
104353     try {
104354       result = (bool)proxy->Empty();
104355     } catch (std::out_of_range& e) {
104356       {
104357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104358       };
104359     } catch (std::exception& e) {
104360       {
104361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104362       };
104363     } catch (Dali::DaliException e) {
104364       {
104365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104366       };
104367     } catch (...) {
104368       {
104369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104370       };
104371     }
104372   }
104373   return (unsigned int) result;
104374 }
104375
104376
104377 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_GetConnectionCount(void * jarg1)
104378 {
104379   std::size_t result;
104380   WebViewSignalProxy* arg1 = (WebViewSignalProxy*) jarg1;
104381   {
104382     try {
104383       result = arg1->GetConnectionCount();
104384     } catch (std::out_of_range& e) {
104385       {
104386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104387       };
104388     } catch (std::exception& e) {
104389       {
104390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104391       };
104392     } catch (Dali::DaliException e) {
104393       {
104394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104395       };
104396     } catch (...) {
104397       {
104398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104399       };
104400     }
104401   }
104402   return (unsigned long) result;
104403 }
104404
104405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Connect(void * jarg1, void * jarg2)
104406 {
104407   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104408   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104409   {
104410     try {
104411       proxy->Connect(callback);
104412     } catch (std::out_of_range& e) {
104413       {
104414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104415       };
104416     } catch (std::exception& e) {
104417       {
104418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104419       };
104420     } catch (Dali::DaliException e) {
104421       {
104422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104423       };
104424     } catch (...) {
104425       {
104426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104427       };
104428     }
104429   }
104430 }
104431
104432
104433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Disconnect(void * jarg1, void * jarg2) {
104434   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104435   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104436   {
104437     try {
104438       proxy->Disconnect(callback);
104439     } catch (std::out_of_range& e) {
104440       {
104441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104442       };
104443     } catch (std::exception& e) {
104444       {
104445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104446       };
104447     } catch (Dali::DaliException e) {
104448       {
104449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104450       };
104451     } catch (...) {
104452       {
104453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104454       };
104455     }
104456   }
104457 }
104458
104459
104460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Emit(void * jarg1, void * jarg2, char * jarg3) {
104461   if (!jarg2) {
104462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView & type is null", 0);
104463     return ;
104464   }
104465   if (!jarg3) {
104466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0);
104467     return ;
104468   }
104469
104470   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104471   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*) jarg2;
104472   {
104473     try {
104474       proxy->Emit(*webview, jarg3);
104475     } catch (std::out_of_range& e) {
104476       {
104477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104478       };
104479     } catch (std::exception& e) {
104480       {
104481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104482       };
104483     } catch (Dali::DaliException e) {
104484       {
104485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104486       };
104487     } catch (...) {
104488       {
104489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104490       };
104491     }
104492   }
104493 }
104494
104495 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
104496   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
104497   char * jresult = SWIG_csharp_string_callback((const char *)result);
104498   return jresult;
104499 }
104500
104501 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
104502   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
104503   return result;
104504 }
104505
104506 #ifdef __cplusplus
104507 }
104508 #endif
104509