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 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.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 #include "web-view-signal-converter.h"
 478
 479
 480 // add here SWIG version check
 481
 482 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 483 // disable Swig-dependent warnings
 484
 485 // 'identifier1' has C-linkage specified,
 486 // but returns UDT 'identifier2' which is incompatible with C
 487 #pragma warning(disable: 4190)
 488
 489 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 490 #pragma warning(disable: 4800)
 491
 492 // debug info too long etc etc
 493 #pragma warning(disable: 4786)
 494 #endif
 495
 496
 497 #include <stdexcept>
 498
 499
 500 #include <string>
 501
 502
 503 #include <vector>
 504 #include <algorithm>
 505 #include <stdexcept>
 506
 507
 508 #include <map>
 509 #include <algorithm>
 510 #include <stdexcept>
 511
 512
 513 #include <utility>
 514
 515
 516 typedef float floatp;
 517
 518 SWIGINTERN floatp *new_floatp(){
 519   return new float();
 520 }
 521 SWIGINTERN void delete_floatp(floatp *self){
 522   if (self) delete self;
 523 }
 524 SWIGINTERN void floatp_assign(floatp *self,float value){
 525   *self = value;
 526 }
 527 SWIGINTERN float floatp_value(floatp *self){
 528   return *self;
 529 }
 530 SWIGINTERN float *floatp_cast(floatp *self){
 531   return self;
 532 }
 533 SWIGINTERN floatp *floatp_frompointer(float *t){
 534   return (floatp *) t;
 535 }
 536
 537 typedef int intp;
 538
 539 SWIGINTERN intp *new_intp(){
 540   return new int();
 541 }
 542 SWIGINTERN void delete_intp(intp *self){
 543   if (self) delete self;
 544 }
 545 SWIGINTERN void intp_assign(intp *self,int value){
 546   *self = value;
 547 }
 548 SWIGINTERN int intp_value(intp *self){
 549   return *self;
 550 }
 551 SWIGINTERN int *intp_cast(intp *self){
 552   return self;
 553 }
 554 SWIGINTERN intp *intp_frompointer(int *t){
 555   return (intp *) t;
 556 }
 557
 558 typedef double doublep;
 559
 560 SWIGINTERN doublep *new_doublep(){
 561   return new double();
 562 }
 563 SWIGINTERN void delete_doublep(doublep *self){
 564   if (self) delete self;
 565 }
 566 SWIGINTERN void doublep_assign(doublep *self,double value){
 567   *self = value;
 568 }
 569 SWIGINTERN double doublep_value(doublep *self){
 570   return *self;
 571 }
 572 SWIGINTERN double *doublep_cast(doublep *self){
 573   return self;
 574 }
 575 SWIGINTERN doublep *doublep_frompointer(double *t){
 576   return (doublep *) t;
 577 }
 578
 579 typedef unsigned int uintp;
 580
 581 SWIGINTERN uintp *new_uintp(){
 582   return new unsigned int();
 583 }
 584 SWIGINTERN void delete_uintp(uintp *self){
 585   if (self) delete self;
 586 }
 587 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 588   *self = value;
 589 }
 590 SWIGINTERN unsigned int uintp_value(uintp *self){
 591   return *self;
 592 }
 593 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 594   return self;
 595 }
 596 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 597   return (uintp *) t;
 598 }
 599
 600 typedef unsigned short ushortp;
 601
 602 SWIGINTERN ushortp *new_ushortp(){
 603   return new unsigned short();
 604 }
 605 SWIGINTERN void delete_ushortp(ushortp *self){
 606   if (self) delete self;
 607 }
 608 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 609   *self = value;
 610 }
 611 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 612   return *self;
 613 }
 614 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 615   return self;
 616 }
 617 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 618   return (ushortp *) t;
 619 }
 620
 621 unsigned int int_to_uint(int x) {
 622    return (unsigned int) x;
 623 }
 624
 625
 626 using namespace Dali;
 627 using namespace Dali::Toolkit;
 628
 629 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 630 {
 631   bool result = false;
 632   try
 633   {
 634     // C++ code. DALi uses Handle <-> Body design pattern.
 635     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 636     // Handles in DALi can be converted into a boolean type
 637     // to check if the handle has a valid body attached to it.
 638     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 639     if( *self )
 640     {
 641       result = true;
 642     }
 643     else
 644     {
 645       result = false;
 646     }
 647   }
 648   catch (std::out_of_range& e)
 649   {
 650     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 651     return 0;
 652   }
 653   catch (std::exception& e)
 654   {
 655     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 656     return 0;
 657   }
 658   catch (DaliException e)
 659   {
 660     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 661     return 0;
 662   }
 663   catch (...)
 664   {
 665     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 666     return 0;
 667   }
 668   return result;
 669 }
 670
 671 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 672 {
 673   bool result = false;
 674   try
 675   {
 676     // C++ code. Check if two handles reference the same implemtion
 677     if( *self == rhs)
 678     {
 679       result = true;
 680     }
 681     else
 682     {
 683       result = false;
 684     }
 685   }
 686   catch (std::out_of_range& e)
 687   {
 688     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 689     return 0;
 690   }
 691   catch (std::exception& e)
 692   {
 693     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 694     return 0;
 695   }
 696   catch (DaliException e)
 697   {
 698     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 699     return 0;
 700   }
 701   catch (...)
 702   {
 703     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 704     return 0;
 705   }
 706   return result;
 707 }
 708
 709
 710 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 711      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 712    }
 713 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){
 714      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 715    }
 716 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 717         std::vector< Dali::TouchPoint >* pv = 0;
 718         if (capacity >= 0) {
 719           pv = new std::vector< Dali::TouchPoint >();
 720           pv->reserve(capacity);
 721        } else {
 722           throw std::out_of_range("capacity");
 723        }
 724        return pv;
 725       }
 726 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 727         if (index>=0 && index<(int)self->size())
 728           return (*self)[index];
 729         else
 730           throw std::out_of_range("index");
 731       }
 732 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 733         if (index>=0 && index<(int)self->size())
 734           return (*self)[index];
 735         else
 736           throw std::out_of_range("index");
 737       }
 738 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 739         if (index>=0 && index<(int)self->size())
 740           (*self)[index] = val;
 741         else
 742           throw std::out_of_range("index");
 743       }
 744 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 745         self->insert(self->end(), values.begin(), values.end());
 746       }
 747 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 748         if (index < 0)
 749           throw std::out_of_range("index");
 750         if (count < 0)
 751           throw std::out_of_range("count");
 752         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 753           throw std::invalid_argument("invalid range");
 754         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 755       }
 756 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 757         if (index>=0 && index<(int)self->size()+1)
 758           self->insert(self->begin()+index, x);
 759         else
 760           throw std::out_of_range("index");
 761       }
 762 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 763         if (index>=0 && index<(int)self->size()+1)
 764           self->insert(self->begin()+index, values.begin(), values.end());
 765         else
 766           throw std::out_of_range("index");
 767       }
 768 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 769         if (index>=0 && index<(int)self->size())
 770           self->erase(self->begin() + index);
 771         else
 772           throw std::out_of_range("index");
 773       }
 774 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 775         if (index < 0)
 776           throw std::out_of_range("index");
 777         if (count < 0)
 778           throw std::out_of_range("count");
 779         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 780           throw std::invalid_argument("invalid range");
 781         self->erase(self->begin()+index, self->begin()+index+count);
 782       }
 783 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 784         if (count < 0)
 785           throw std::out_of_range("count");
 786         return new std::vector< Dali::TouchPoint >(count, value);
 787       }
 788 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 789         std::reverse(self->begin(), self->end());
 790       }
 791 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 792         if (index < 0)
 793           throw std::out_of_range("index");
 794         if (count < 0)
 795           throw std::out_of_range("count");
 796         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 797           throw std::invalid_argument("invalid range");
 798         std::reverse(self->begin()+index, self->begin()+index+count);
 799       }
 800 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 801         if (index < 0)
 802           throw std::out_of_range("index");
 803         if (index+values.size() > self->size())
 804           throw std::out_of_range("index");
 805         std::copy(values.begin(), values.end(), self->begin()+index);
 806       }
 807 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 808          return self->Empty();
 809       }
 810 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 811         return self->GetConnectionCount();
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 814           self->Connect( func );
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 817           self->Disconnect( func );
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 820           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 821 /*@SWIG@*/ self->Emit( arg );
 822       }
 823 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 824          return self->Empty();
 825       }
 826 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 827         return self->GetConnectionCount();
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 830           self->Connect( func );
 831       }
 832 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 833           self->Disconnect( func );
 834       }
 835 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 836           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 837 /*@SWIG@*/ self->Emit( arg );
 838       }
 839 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 840          return self->Empty();
 841       }
 842 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){
 843         return self->GetConnectionCount();
 844       }
 845 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 *)){
 846           self->Connect( func );
 847       }
 848 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 *)){
 849           self->Disconnect( func );
 850       }
 851 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){
 852           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 853 /*@SWIG@*/ self->Emit( arg );
 854       }
 855 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 856          return self->Empty();
 857       }
 858 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 859         return self->GetConnectionCount();
 860       }
 861 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 862           self->Connect( func );
 863       }
 864 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 865           self->Disconnect( func );
 866       }
 867 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 868           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 869 /*@SWIG@*/ self->Emit( arg );
 870       }
 871 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 872          return self->Empty();
 873       }
 874 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 875         return self->GetConnectionCount();
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 878           self->Connect( func );
 879       }
 880 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 881           self->Disconnect( func );
 882       }
 883 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 884           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 885 /*@SWIG@*/ self->Emit( arg );
 886       }
 887 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){
 888          return self->Empty();
 889       }
 890 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){
 891         return self->GetConnectionCount();
 892       }
 893 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 &)){
 894         self->Connect( func );
 895       }
 896 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 &)){
 897         self->Disconnect( func );
 898       }
 899 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){
 900         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 901 /*@SWIG@*/ self->Emit( arg1, arg2 );
 902       }
 903 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){
 904          return self->Empty();
 905       }
 906 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){
 907         return self->GetConnectionCount();
 908       }
 909 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 &)){
 910         self->Connect( func );
 911       }
 912 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 &)){
 913         self->Disconnect( func );
 914       }
 915 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){
 916         return self->Emit( arg1, arg2 );
 917       }
 918 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){
 919          return self->Empty();
 920       }
 921 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){
 922         return self->GetConnectionCount();
 923       }
 924 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 &)){
 925         self->Connect( func );
 926       }
 927 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 &)){
 928         self->Disconnect( func );
 929       }
 930 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){
 931         return self->Emit( arg1, arg2 );
 932       }
 933 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){
 934          return self->Empty();
 935       }
 936 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){
 937         return self->GetConnectionCount();
 938       }
 939 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 &)){
 940         self->Connect( func );
 941       }
 942 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 &)){
 943         self->Disconnect( func );
 944       }
 945 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){
 946         return self->Emit( arg1, arg2 );
 947       }
 948 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 949          return self->Empty();
 950       }
 951 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 952         return self->GetConnectionCount();
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 955           self->Connect( func );
 956       }
 957 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 958           self->Disconnect( func );
 959       }
 960 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 961           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 962 /*@SWIG@*/ self->Emit( arg );
 963       }
 964 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 965          return self->Empty();
 966       }
 967 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){
 968         return self->GetConnectionCount();
 969       }
 970 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 &)){
 971           self->Connect( func );
 972       }
 973 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 &)){
 974           self->Disconnect( func );
 975       }
 976 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){
 977           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 978 /*@SWIG@*/ self->Emit( arg );
 979       }
 980 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 981          return self->Empty();
 982       }
 983 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){
 984         return self->GetConnectionCount();
 985       }
 986 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 &)){
 987           self->Connect( func );
 988       }
 989 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 &)){
 990           self->Disconnect( func );
 991       }
 992 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){
 993           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 994 /*@SWIG@*/ self->Emit( arg );
 995       }
 996 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 997          return self->Empty();
 998       }
 999 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){
1000         return self->GetConnectionCount();
1001       }
1002 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 &)){
1003           self->Connect( func );
1004       }
1005 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 &)){
1006           self->Disconnect( func );
1007       }
1008 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){
1009           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1010 /*@SWIG@*/ self->Emit( arg );
1011       }
1012 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){
1013          return self->Empty();
1014       }
1015 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){
1016         return self->GetConnectionCount();
1017       }
1018 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 &)){
1019         self->Connect( func );
1020       }
1021 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 &)){
1022         self->Disconnect( func );
1023       }
1024 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){
1025         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1026 /*@SWIG@*/ self->Emit( arg1, arg2 );
1027       }
1028 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){
1029          return self->Empty();
1030       }
1031 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){
1032         return self->GetConnectionCount();
1033       }
1034 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 &)){
1035         self->Connect( func );
1036       }
1037 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 &)){
1038         self->Disconnect( func );
1039       }
1040 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){
1041         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1042 /*@SWIG@*/ self->Emit( arg1, arg2 );
1043       }
1044 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){
1045          return self->Empty();
1046       }
1047 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){
1048         return self->GetConnectionCount();
1049       }
1050 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 &)){
1051         self->Connect( func );
1052       }
1053 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 &)){
1054         self->Disconnect( func );
1055       }
1056 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){
1057         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1058 /*@SWIG@*/ self->Emit( arg1, arg2 );
1059       }
1060 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1061          return self->Empty();
1062       }
1063 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1064         return self->GetConnectionCount();
1065       }
1066 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1067           self->Connect( func );
1068       }
1069 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1070           self->Disconnect( func );
1071       }
1072 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1073           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1074 /*@SWIG@*/ self->Emit( arg );
1075       }
1076 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){
1077          return self->Empty();
1078       }
1079 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){
1080         return self->GetConnectionCount();
1081       }
1082 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)){
1083           return self->Connect( func );
1084       }
1085 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)){
1086           self->Disconnect( func );
1087       }
1088 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){
1089           self->Emit( arg1, arg3 );
1090       }
1091 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){
1092          return self->Empty();
1093       }
1094 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){
1095         return self->GetConnectionCount();
1096       }
1097 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)){
1098           return self->Connect( func );
1099       }
1100 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)){
1101           self->Disconnect( func );
1102       }
1103 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){
1104           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1105 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1106       }
1107
1108 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1109          return self->Empty();
1110       }
1111 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1112         return self->GetConnectionCount();
1113       }
1114 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1115           self->Connect( func );
1116       }
1117 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1118           self->Disconnect( func );
1119       }
1120 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1121           return self->Emit();
1122       }
1123
1124 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1125         std::vector< unsigned int >* pv = 0;
1126         if (capacity >= 0) {
1127           pv = new std::vector< unsigned int >();
1128           pv->reserve(capacity);
1129        } else {
1130           throw std::out_of_range("capacity");
1131        }
1132        return pv;
1133       }
1134 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1135         if (index>=0 && index<(int)self->size())
1136           return (*self)[index];
1137         else
1138           throw std::out_of_range("index");
1139       }
1140 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1141         if (index>=0 && index<(int)self->size())
1142           return (*self)[index];
1143         else
1144           throw std::out_of_range("index");
1145       }
1146 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1147         if (index>=0 && index<(int)self->size())
1148           (*self)[index] = val;
1149         else
1150           throw std::out_of_range("index");
1151       }
1152 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1153         self->insert(self->end(), values.begin(), values.end());
1154       }
1155 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1156         if (index < 0)
1157           throw std::out_of_range("index");
1158         if (count < 0)
1159           throw std::out_of_range("count");
1160         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1161           throw std::invalid_argument("invalid range");
1162         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1163       }
1164 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1165         if (index>=0 && index<(int)self->size()+1)
1166           self->insert(self->begin()+index, x);
1167         else
1168           throw std::out_of_range("index");
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1171         if (index>=0 && index<(int)self->size()+1)
1172           self->insert(self->begin()+index, values.begin(), values.end());
1173         else
1174           throw std::out_of_range("index");
1175       }
1176 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1177         if (index>=0 && index<(int)self->size())
1178           self->erase(self->begin() + index);
1179         else
1180           throw std::out_of_range("index");
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1183         if (index < 0)
1184           throw std::out_of_range("index");
1185         if (count < 0)
1186           throw std::out_of_range("count");
1187         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1188           throw std::invalid_argument("invalid range");
1189         self->erase(self->begin()+index, self->begin()+index+count);
1190       }
1191 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1192         if (count < 0)
1193           throw std::out_of_range("count");
1194         return new std::vector< unsigned int >(count, value);
1195       }
1196 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1197         std::reverse(self->begin(), self->end());
1198       }
1199 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1200         if (index < 0)
1201           throw std::out_of_range("index");
1202         if (count < 0)
1203           throw std::out_of_range("count");
1204         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1205           throw std::invalid_argument("invalid range");
1206         std::reverse(self->begin()+index, self->begin()+index+count);
1207       }
1208 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1209         if (index < 0)
1210           throw std::out_of_range("index");
1211         if (index+values.size() > self->size())
1212           throw std::out_of_range("index");
1213         std::copy(values.begin(), values.end(), self->begin()+index);
1214       }
1215 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1216         return std::find(self->begin(), self->end(), value) != self->end();
1217       }
1218 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1219         int index = -1;
1220         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1221         if (it != self->end())
1222           index = (int)(it - self->begin());
1223         return index;
1224       }
1225 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1226         int index = -1;
1227         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1228         if (rit != self->rend())
1229           index = (int)(self->rend() - 1 - rit);
1230         return index;
1231       }
1232 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1233         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1234         if (it != self->end()) {
1235           self->erase(it);
1236           return true;
1237         }
1238         return false;
1239       }
1240 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){
1241         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1242         if (capacity >= 0) {
1243           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1244           pv->reserve(capacity);
1245        } else {
1246           throw std::out_of_range("capacity");
1247        }
1248        return pv;
1249       }
1250 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){
1251         if (index>=0 && index<(int)self->size())
1252           return (*self)[index];
1253         else
1254           throw std::out_of_range("index");
1255       }
1256 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){
1257         if (index>=0 && index<(int)self->size())
1258           return (*self)[index];
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1263         if (index>=0 && index<(int)self->size())
1264           (*self)[index] = val;
1265         else
1266           throw std::out_of_range("index");
1267       }
1268 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){
1269         self->insert(self->end(), values.begin(), values.end());
1270       }
1271 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){
1272         if (index < 0)
1273           throw std::out_of_range("index");
1274         if (count < 0)
1275           throw std::out_of_range("count");
1276         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1277           throw std::invalid_argument("invalid range");
1278         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1279       }
1280 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){
1281         if (index>=0 && index<(int)self->size()+1)
1282           self->insert(self->begin()+index, x);
1283         else
1284           throw std::out_of_range("index");
1285       }
1286 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1287         if (index>=0 && index<(int)self->size()+1)
1288           self->insert(self->begin()+index, values.begin(), values.end());
1289         else
1290           throw std::out_of_range("index");
1291       }
1292 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1293         if (index>=0 && index<(int)self->size())
1294           self->erase(self->begin() + index);
1295         else
1296           throw std::out_of_range("index");
1297       }
1298 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){
1299         if (index < 0)
1300           throw std::out_of_range("index");
1301         if (count < 0)
1302           throw std::out_of_range("count");
1303         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1304           throw std::invalid_argument("invalid range");
1305         self->erase(self->begin()+index, self->begin()+index+count);
1306       }
1307 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){
1308         if (count < 0)
1309           throw std::out_of_range("count");
1310         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1311       }
1312 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){
1313         std::reverse(self->begin(), self->end());
1314       }
1315 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){
1316         if (index < 0)
1317           throw std::out_of_range("index");
1318         if (count < 0)
1319           throw std::out_of_range("count");
1320         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1321           throw std::invalid_argument("invalid range");
1322         std::reverse(self->begin()+index, self->begin()+index+count);
1323       }
1324 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){
1325         if (index < 0)
1326           throw std::out_of_range("index");
1327         if (index+values.size() > self->size())
1328           throw std::out_of_range("index");
1329         std::copy(values.begin(), values.end(), self->begin()+index);
1330       }
1331 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1332         std::vector< Dali::Actor >* pv = 0;
1333         if (capacity >= 0) {
1334           pv = new std::vector< Dali::Actor >();
1335           pv->reserve(capacity);
1336        } else {
1337           throw std::out_of_range("capacity");
1338        }
1339        return pv;
1340       }
1341 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1342         if (index>=0 && index<(int)self->size())
1343           return (*self)[index];
1344         else
1345           throw std::out_of_range("index");
1346       }
1347 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1348         if (index>=0 && index<(int)self->size())
1349           return (*self)[index];
1350         else
1351           throw std::out_of_range("index");
1352       }
1353 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1354         if (index>=0 && index<(int)self->size())
1355           (*self)[index] = val;
1356         else
1357           throw std::out_of_range("index");
1358       }
1359 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1360         self->insert(self->end(), values.begin(), values.end());
1361       }
1362 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1363         if (index < 0)
1364           throw std::out_of_range("index");
1365         if (count < 0)
1366           throw std::out_of_range("count");
1367         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1368           throw std::invalid_argument("invalid range");
1369         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1370       }
1371 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1372         if (index>=0 && index<(int)self->size()+1)
1373           self->insert(self->begin()+index, x);
1374         else
1375           throw std::out_of_range("index");
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1378         if (index>=0 && index<(int)self->size()+1)
1379           self->insert(self->begin()+index, values.begin(), values.end());
1380         else
1381           throw std::out_of_range("index");
1382       }
1383 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1384         if (index>=0 && index<(int)self->size())
1385           self->erase(self->begin() + index);
1386         else
1387           throw std::out_of_range("index");
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1390         if (index < 0)
1391           throw std::out_of_range("index");
1392         if (count < 0)
1393           throw std::out_of_range("count");
1394         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1395           throw std::invalid_argument("invalid range");
1396         self->erase(self->begin()+index, self->begin()+index+count);
1397       }
1398 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1399         if (count < 0)
1400           throw std::out_of_range("count");
1401         return new std::vector< Dali::Actor >(count, value);
1402       }
1403 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1404         std::reverse(self->begin(), self->end());
1405       }
1406 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1407         if (index < 0)
1408           throw std::out_of_range("index");
1409         if (count < 0)
1410           throw std::out_of_range("count");
1411         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1412           throw std::invalid_argument("invalid range");
1413         std::reverse(self->begin()+index, self->begin()+index+count);
1414       }
1415 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1416         if (index < 0)
1417           throw std::out_of_range("index");
1418         if (index+values.size() > self->size())
1419           throw std::out_of_range("index");
1420         std::copy(values.begin(), values.end(), self->begin()+index);
1421       }
1422 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1423          return self->Empty();
1424       }
1425 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1426         return self->GetConnectionCount();
1427       }
1428 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 &)){
1429           self->Connect( func );
1430       }
1431 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 &)){
1432           self->Disconnect( func );
1433       }
1434 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){
1435           return self->Emit( arg );
1436       }
1437 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){
1438          return self->Empty();
1439       }
1440 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){
1441         return self->GetConnectionCount();
1442       }
1443 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)){
1444         self->Connect( func );
1445       }
1446 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)){
1447         self->Disconnect( func );
1448       }
1449 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){
1450         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1451 /*@SWIG@*/ self->Emit( arg1, arg2 );
1452       }
1453 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1454          return self->Empty();
1455       }
1456 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){
1457         return self->GetConnectionCount();
1458       }
1459 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)){
1460         self->Connect( func );
1461       }
1462 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)){
1463         self->Disconnect( func );
1464       }
1465 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){
1466         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1467 /*@SWIG@*/ self->Emit( arg1, arg2 );
1468       }
1469 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1470          return self->Empty();
1471       }
1472 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1473         return self->GetConnectionCount();
1474       }
1475 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)){
1476         self->Connect( func );
1477       }
1478 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)){
1479         self->Disconnect( func );
1480       }
1481 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){
1482         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1483 /*@SWIG@*/ self->Emit( arg1, arg2 );
1484       }
1485 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){
1486          return self->Empty();
1487       }
1488 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){
1489         return self->GetConnectionCount();
1490       }
1491 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)){
1492         self->Connect( func );
1493       }
1494 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)){
1495         self->Disconnect( func );
1496       }
1497 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){
1498         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1499 /*@SWIG@*/ self->Emit( arg1, arg2 );
1500       }
1501 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1502          return self->Empty();
1503       }
1504 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1505         return self->GetConnectionCount();
1506       }
1507 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)){
1508           self->Connect( func );
1509       }
1510 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)){
1511           self->Disconnect( func );
1512       }
1513 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1514           return self->Emit( arg );
1515       }
1516 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1517          return self->Empty();
1518       }
1519 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1520         return self->GetConnectionCount();
1521       }
1522 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)){
1523           self->Connect( func );
1524       }
1525 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)){
1526           self->Disconnect( func );
1527       }
1528 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1529           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1530 /*@SWIG@*/ self->Emit( arg );
1531       }
1532 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){
1533          return self->Empty();
1534       }
1535 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){
1536         return self->GetConnectionCount();
1537       }
1538 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)){
1539           return self->Connect( func );
1540       }
1541 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)){
1542           self->Disconnect( func );
1543       }
1544 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){
1545           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1546 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1547       }
1548 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1549          return self->Empty();
1550       }
1551 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1552         return self->GetConnectionCount();
1553       }
1554 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)){
1555           self->Connect( func );
1556       }
1557 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)){
1558           self->Disconnect( func );
1559       }
1560 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1561           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1562 /*@SWIG@*/ self->Emit( arg );
1563       }
1564 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){
1565          return self->Empty();
1566       }
1567 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){
1568         return self->GetConnectionCount();
1569       }
1570 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)){
1571           return self->Connect( func );
1572       }
1573 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)){
1574           self->Disconnect( func );
1575       }
1576 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){
1577           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1578 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1579       }
1580 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){
1581          return self->Empty();
1582       }
1583 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){
1584         return self->GetConnectionCount();
1585       }
1586 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 &)){
1587           self->Connect( func );
1588       }
1589 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 &)){
1590           self->Disconnect( func );
1591       }
1592 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){
1593           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1594 /*@SWIG@*/ self->Emit( arg );
1595       }
1596 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1597          return self->Empty();
1598       }
1599 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){
1600         return self->GetConnectionCount();
1601       }
1602 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 &)){
1603           self->Connect( func );
1604       }
1605 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 &)){
1606           self->Disconnect( func );
1607       }
1608 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){
1609           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1610 /*@SWIG@*/ self->Emit( arg );
1611       }
1612
1613
1614 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){
1615          return self->Empty();
1616       }
1617 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){
1618         return self->GetConnectionCount();
1619       }
1620 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 &)){
1621         self->Connect( func );
1622       }
1623 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 &)){
1624         self->Disconnect( func );
1625       }
1626 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){
1627         return self->Emit( arg1, arg2 );
1628       }
1629 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1630          return self->Empty();
1631       }
1632 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1633         return self->GetConnectionCount();
1634       }
1635 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)){
1636           self->Connect( func );
1637       }
1638 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)){
1639           self->Disconnect( func );
1640       }
1641 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1642           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1643 /*@SWIG@*/ self->Emit( arg );
1644       }
1645 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1646          return self->Empty();
1647       }
1648 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1649         return self->GetConnectionCount();
1650       }
1651 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 &)){
1652           self->Connect( func );
1653       }
1654 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 &)){
1655           self->Disconnect( func );
1656       }
1657 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){
1658           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1659 /*@SWIG@*/ self->Emit( arg );
1660       }
1661 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1662          return self->Empty();
1663       }
1664 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){
1665         return self->GetConnectionCount();
1666       }
1667 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)){
1668         self->Connect( func );
1669       }
1670 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)){
1671         self->Disconnect( func );
1672       }
1673 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){
1674         return self->Emit( arg1, arg2 );
1675       }
1676 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1677          return self->Empty();
1678       }
1679 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){
1680         return self->GetConnectionCount();
1681       }
1682 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)){
1683         self->Connect( func );
1684       }
1685 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)){
1686         self->Disconnect( func );
1687       }
1688 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){
1689         return self->Emit( arg1, arg2 );
1690       }
1691
1692 /* ---------------------------------------------------
1693  * C++ director class methods
1694  * --------------------------------------------------- */
1695
1696 #include "dali_wrap.h"
1697
1698 /*
1699  *  Widget director
1700  */
1701 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1702   swig_init_callbacks();
1703 }
1704
1705 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1706 }
1707
1708 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1709   char * jcontentInfo = 0 ;
1710   void * jwindow  ;
1711
1712   if (!swig_callbackOnCreate) {
1713     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1714     return;
1715   } else {
1716     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1717     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1718     swig_callbackOnCreate(jcontentInfo, jwindow);
1719   }
1720 }
1721
1722 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1723   char * jcontentInfo = 0 ;
1724   int jtype  ;
1725
1726   if (!swig_callbackOnTerminate) {
1727     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1728     return;
1729   } else {
1730     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1731     jtype = (int)type;
1732     swig_callbackOnTerminate(jcontentInfo, jtype);
1733   }
1734 }
1735
1736 void SwigDirector_WidgetImpl::OnPause() {
1737   if (!swig_callbackOnPause) {
1738     Dali::Internal::Adaptor::Widget::OnPause();
1739     return;
1740   } else {
1741     swig_callbackOnPause();
1742   }
1743 }
1744
1745 void SwigDirector_WidgetImpl::OnResume() {
1746   if (!swig_callbackOnResume) {
1747     Dali::Internal::Adaptor::Widget::OnResume();
1748     return;
1749   } else {
1750     swig_callbackOnResume();
1751   }
1752 }
1753
1754 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1755   void * jwindow  ;
1756
1757   if (!swig_callbackOnResize) {
1758     Dali::Internal::Adaptor::Widget::OnResize(window);
1759     return;
1760   } else {
1761     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1762     swig_callbackOnResize(jwindow);
1763   }
1764 }
1765
1766 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1767   char * jcontentInfo = 0 ;
1768   int jforce  ;
1769
1770   if (!swig_callbackOnUpdate) {
1771     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1772     return;
1773   } else {
1774     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1775     jforce = force;
1776     swig_callbackOnUpdate(jcontentInfo, jforce);
1777   }
1778 }
1779
1780 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1781   void * jslotObserver = 0 ;
1782   void * jcallback = 0 ;
1783
1784   if (!swig_callbackSignalConnected) {
1785     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1786     return;
1787   } else {
1788     jslotObserver = (void *) slotObserver;
1789     jcallback = (void *) callback;
1790     swig_callbackSignalConnected(jslotObserver, jcallback);
1791   }
1792 }
1793
1794 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1795   void * jslotObserver = 0 ;
1796   void * jcallback = 0 ;
1797
1798   if (!swig_callbackSignalDisconnected) {
1799     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1800     return;
1801   } else {
1802     jslotObserver = (void *) slotObserver;
1803     jcallback = (void *) callback;
1804     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1805   }
1806 }
1807
1808 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) {
1809
1810   swig_callbackOnCreate = callbackOnCreate;
1811   swig_callbackOnTerminate = callbackOnTerminate;
1812   swig_callbackOnPause = callbackOnPause;
1813   swig_callbackOnResume = callbackOnResume;
1814   swig_callbackOnResize = callbackOnResize;
1815   swig_callbackOnUpdate = callbackOnUpdate;
1816   swig_callbackSignalConnected = callbackSignalConnected;
1817   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1818 }
1819
1820 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1821   swig_callbackOnCreate = 0;
1822   swig_callbackOnTerminate = 0;
1823   swig_callbackOnPause = 0;
1824   swig_callbackOnResume = 0;
1825   swig_callbackOnResize = 0;
1826   swig_callbackOnUpdate = 0;
1827   swig_callbackSignalConnected = 0;
1828   swig_callbackSignalDisconnected = 0;
1829 }
1830
1831
1832 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1833   swig_init_callbacks();
1834 }
1835
1836 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1837
1838 }
1839
1840
1841 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1842   int jdepth  ;
1843
1844   if (!swig_callbackOnStageConnection) {
1845     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1846     return;
1847   } else {
1848     jdepth = depth;
1849     swig_callbackOnStageConnection(jdepth);
1850   }
1851 }
1852
1853 void SwigDirector_ViewImpl::OnStageDisconnection() {
1854   if (!swig_callbackOnStageDisconnection) {
1855     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1856     return;
1857   } else {
1858     swig_callbackOnStageDisconnection();
1859   }
1860 }
1861
1862 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1863   void * jchild = 0 ;
1864
1865   if (!swig_callbackOnChildAdd) {
1866     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1867     return;
1868   } else {
1869     jchild = (Dali::Actor *) &child;
1870     swig_callbackOnChildAdd(jchild);
1871   }
1872 }
1873
1874 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1875   void * jchild = 0 ;
1876
1877   if (!swig_callbackOnChildRemove) {
1878     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1879     return;
1880   } else {
1881     jchild = (Dali::Actor *) &child;
1882     swig_callbackOnChildRemove(jchild);
1883   }
1884 }
1885
1886 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1887   int jindex  ;
1888   void * jpropertyValue  ;
1889
1890   if (!swig_callbackOnPropertySet) {
1891     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1892     return;
1893   } else {
1894     jindex = index;
1895     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1896     swig_callbackOnPropertySet(jindex, jpropertyValue);
1897   }
1898 }
1899
1900 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1901   void * jtargetSize = 0 ;
1902
1903   if (!swig_callbackOnSizeSet) {
1904     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1905     return;
1906   } else {
1907     jtargetSize = (Dali::Vector3 *) &targetSize;
1908     swig_callbackOnSizeSet(jtargetSize);
1909   }
1910 }
1911
1912 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1913   void * janimation = 0 ;
1914   void * jtargetSize = 0 ;
1915
1916   if (!swig_callbackOnSizeAnimation) {
1917     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1918     return;
1919   } else {
1920     janimation = (Dali::Animation *) &animation;
1921     jtargetSize = (Dali::Vector3 *) &targetSize;
1922     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1923   }
1924 }
1925
1926 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1927   bool c_result = SwigValueInit< bool >() ;
1928   unsigned int jresult = 0 ;
1929   void * jarg0 = 0 ;
1930
1931   if (!swig_callbackOnTouchEvent) {
1932     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1933   } else {
1934     jarg0 = (Dali::TouchEvent *) &event;
1935     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1936     c_result = jresult ? true : false;
1937   }
1938   return c_result;
1939 }
1940
1941 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1942   bool c_result = SwigValueInit< bool >() ;
1943   unsigned int jresult = 0 ;
1944   void * jarg0 = 0 ;
1945
1946   if (!swig_callbackOnHoverEvent) {
1947     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1948   } else {
1949     jarg0 = (Dali::HoverEvent *) &event;
1950     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1951     c_result = jresult ? true : false;
1952   }
1953   return c_result;
1954 }
1955
1956 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1957   bool c_result = SwigValueInit< bool >() ;
1958   unsigned int jresult = 0 ;
1959   void * jarg0 = 0 ;
1960
1961   if (!swig_callbackOnKeyEvent) {
1962     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1963   } else {
1964     jarg0 = (Dali::KeyEvent *) &event;
1965     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1966     c_result = jresult ? true : false;
1967   }
1968   return c_result;
1969 }
1970
1971 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1972   bool c_result = SwigValueInit< bool >() ;
1973   unsigned int jresult = 0 ;
1974   void * jarg0 = 0 ;
1975
1976   if (!swig_callbackOnWheelEvent) {
1977     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1978   } else {
1979     jarg0 = (Dali::WheelEvent *) &event;
1980     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1981     c_result = jresult ? true : false;
1982   }
1983   return c_result;
1984 }
1985
1986 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1987   void * jsize = 0 ;
1988   void * jcontainer = 0 ;
1989
1990   if (!swig_callbackOnRelayout) {
1991     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1992     return;
1993   } else {
1994     jsize = (Dali::Vector2 *) &size;
1995     jcontainer = (Dali::RelayoutContainer *) &container;
1996     swig_callbackOnRelayout(jsize, jcontainer);
1997   }
1998 }
1999
2000 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2001   int jpolicy  ;
2002   int jdimension  ;
2003
2004   if (!swig_callbackOnSetResizePolicy) {
2005     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2006     return;
2007   } else {
2008     jpolicy = (int)policy;
2009     jdimension = (int)dimension;
2010     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2011   }
2012 }
2013
2014 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2015   Dali::Vector3 c_result ;
2016   void * jresult = 0 ;
2017
2018   if (!swig_callbackGetNaturalSize) {
2019     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2020   } else {
2021     jresult = (void *) swig_callbackGetNaturalSize();
2022     if (!jresult) {
2023       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2024       return c_result;
2025     }
2026     c_result = *(Dali::Vector3 *)jresult;
2027   }
2028   return c_result;
2029 }
2030
2031 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2032   float c_result = SwigValueInit< float >() ;
2033   float jresult = 0 ;
2034   void * jchild = 0 ;
2035   int jdimension  ;
2036
2037   if (!swig_callbackCalculateChildSize) {
2038     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2039   } else {
2040     jchild = (Dali::Actor *) &child;
2041     jdimension = (int)dimension;
2042     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2043     c_result = (float)jresult;
2044   }
2045   return c_result;
2046 }
2047
2048 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2049   float c_result = SwigValueInit< float >() ;
2050   float jresult = 0 ;
2051   float jwidth  ;
2052
2053   if (!swig_callbackGetHeightForWidth) {
2054     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2055   } else {
2056     jwidth = width;
2057     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2058     c_result = (float)jresult;
2059   }
2060   return c_result;
2061 }
2062
2063 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2064   float c_result = SwigValueInit< float >() ;
2065   float jresult = 0 ;
2066   float jheight  ;
2067
2068   if (!swig_callbackGetWidthForHeight) {
2069     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2070   } else {
2071     jheight = height;
2072     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2073     c_result = (float)jresult;
2074   }
2075   return c_result;
2076 }
2077
2078 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2079   bool c_result = SwigValueInit< bool >() ;
2080   unsigned int jresult = 0 ;
2081   int jdimension  ;
2082
2083   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2084     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2085   } else {
2086     jdimension = (int)dimension;
2087     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2088     c_result = jresult ? true : false;
2089   }
2090   return c_result;
2091 }
2092
2093 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2094   int jdimension  ;
2095
2096   if (!swig_callbackOnCalculateRelayoutSize) {
2097     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2098     return;
2099   } else {
2100     jdimension = (int)dimension;
2101     swig_callbackOnCalculateRelayoutSize(jdimension);
2102   }
2103 }
2104
2105 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2106   float jsize  ;
2107   int jdimension  ;
2108
2109   if (!swig_callbackOnLayoutNegotiated) {
2110     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2111     return;
2112   } else {
2113     jsize = size;
2114     jdimension = (int)dimension;
2115     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2116   }
2117 }
2118
2119 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2120   return Dali::CustomActorImpl::GetExtension();
2121 }
2122
2123 void SwigDirector_ViewImpl::OnInitialize() {
2124   if (!swig_callbackOnInitialize) {
2125     Dali::Toolkit::Internal::Control::OnInitialize();
2126     return;
2127   } else {
2128     swig_callbackOnInitialize();
2129   }
2130 }
2131
2132 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2133   void * jchild = 0 ;
2134
2135   if (!swig_callbackOnControlChildAdd) {
2136     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2137     return;
2138   } else {
2139     jchild = (Dali::Actor *) &child;
2140     swig_callbackOnControlChildAdd(jchild);
2141   }
2142 }
2143
2144 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2145   void * jchild = 0 ;
2146
2147   if (!swig_callbackOnControlChildRemove) {
2148     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2149     return;
2150   } else {
2151     jchild = (Dali::Actor *) &child;
2152     swig_callbackOnControlChildRemove(jchild);
2153   }
2154 }
2155
2156 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2157   void * jstyleManager  ;
2158   int jchange  ;
2159
2160   if (!swig_callbackOnStyleChange) {
2161     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2162     return;
2163   } else {
2164     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2165     jchange = (int)change;
2166     swig_callbackOnStyleChange(jstyleManager, jchange);
2167   }
2168 }
2169
2170 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2171   bool c_result = SwigValueInit< bool >() ;
2172   unsigned int jresult = 0 ;
2173
2174   if (!swig_callbackOnAccessibilityActivated) {
2175     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2176   } else {
2177     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2178     c_result = jresult ? true : false;
2179   }
2180   return c_result;
2181 }
2182
2183 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2184   bool c_result = SwigValueInit< bool >() ;
2185   unsigned int jresult = 0 ;
2186   void * jgesture  ;
2187
2188   if (!swig_callbackOnAccessibilityPan) {
2189     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2190   } else {
2191     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2192     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2193     c_result = jresult ? true : false;
2194   }
2195   return c_result;
2196 }
2197
2198 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2199   bool c_result = SwigValueInit< bool >() ;
2200   unsigned int jresult = 0 ;
2201   void * jtouchEvent = 0 ;
2202
2203   if (!swig_callbackOnAccessibilityTouch) {
2204     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2205   } else {
2206     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2207     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2208     c_result = jresult ? true : false;
2209   }
2210   return c_result;
2211 }
2212
2213 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2214   bool c_result = SwigValueInit< bool >() ;
2215   unsigned int jresult = 0 ;
2216   unsigned int jisIncrease  ;
2217
2218   if (!swig_callbackOnAccessibilityValueChange) {
2219     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2220   } else {
2221     jisIncrease = isIncrease;
2222     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2223     c_result = jresult ? true : false;
2224   }
2225   return c_result;
2226 }
2227
2228 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2229   bool c_result = SwigValueInit< bool >() ;
2230   unsigned int jresult = 0 ;
2231
2232   if (!swig_callbackOnAccessibilityZoom) {
2233     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2234   } else {
2235     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2236     c_result = jresult ? true : false;
2237   }
2238   return c_result;
2239 }
2240
2241 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2242   if (!swig_callbackOnKeyInputFocusGained) {
2243     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2244     return;
2245   } else {
2246     swig_callbackOnKeyInputFocusGained();
2247   }
2248 }
2249
2250 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2251   if (!swig_callbackOnKeyInputFocusLost) {
2252     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2253     return;
2254   } else {
2255     swig_callbackOnKeyInputFocusLost();
2256   }
2257 }
2258
2259 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2260   Dali::Actor c_result ;
2261   void * jresult = 0 ;
2262   void * jcurrentFocusedActor  ;
2263   int jdirection  ;
2264   unsigned int jloopEnabled  ;
2265
2266   if (!swig_callbackGetNextKeyboardFocusableActor) {
2267     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2268   } else {
2269     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2270     jdirection = (int)direction;
2271     jloopEnabled = loopEnabled;
2272     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2273     if (!jresult) {
2274       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2275       return c_result;
2276     }
2277     c_result = *(Dali::Actor *)jresult;
2278   }
2279   return c_result;
2280 }
2281
2282 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2283   void * jcommitedFocusableActor  ;
2284
2285   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2286     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2287     return;
2288   } else {
2289     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2290     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2291   }
2292 }
2293
2294 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2295   bool c_result = SwigValueInit< bool >() ;
2296   unsigned int jresult = 0 ;
2297
2298   if (!swig_callbackOnKeyboardEnter) {
2299     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2300   } else {
2301     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2302     c_result = jresult ? true : false;
2303   }
2304   return c_result;
2305 }
2306
2307 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2308   void * jpinch = 0 ;
2309
2310   if (!swig_callbackOnPinch) {
2311     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2312     return;
2313   } else {
2314     jpinch = (Dali::PinchGesture *) &pinch;
2315     swig_callbackOnPinch(jpinch);
2316   }
2317 }
2318
2319 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2320   void * jpan = 0 ;
2321
2322   if (!swig_callbackOnPan) {
2323     Dali::Toolkit::Internal::Control::OnPan(pan);
2324     return;
2325   } else {
2326     jpan = (Dali::PanGesture *) &pan;
2327     swig_callbackOnPan(jpan);
2328   }
2329 }
2330
2331 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2332   void * jtap = 0 ;
2333
2334   if (!swig_callbackOnTap) {
2335     Dali::Toolkit::Internal::Control::OnTap(tap);
2336     return;
2337   } else {
2338     jtap = (Dali::TapGesture *) &tap;
2339     swig_callbackOnTap(jtap);
2340   }
2341 }
2342
2343 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2344   void * jlongPress = 0 ;
2345
2346   if (!swig_callbackOnLongPress) {
2347     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2348     return;
2349   } else {
2350     jlongPress = (Dali::LongPressGesture *) &longPress;
2351     swig_callbackOnLongPress(jlongPress);
2352   }
2353 }
2354
2355 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2356   void * jslotObserver = 0 ;
2357   void * jcallback = 0 ;
2358
2359   if (!swig_callbackSignalConnected) {
2360     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2361     return;
2362   } else {
2363     jslotObserver = (void *) slotObserver;
2364     jcallback = (void *) callback;
2365     swig_callbackSignalConnected(jslotObserver, jcallback);
2366   }
2367 }
2368
2369 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2370   void * jslotObserver = 0 ;
2371   void * jcallback = 0 ;
2372
2373   if (!swig_callbackSignalDisconnected) {
2374     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2375     return;
2376   } else {
2377     jslotObserver = (void *) slotObserver;
2378     jcallback = (void *) callback;
2379     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2380   }
2381 }
2382
2383 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2384   return Dali::Toolkit::Internal::Control::GetControlExtension();
2385 }
2386
2387 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) {
2388   swig_callbackOnStageConnection = callbackOnStageConnection;
2389   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2390   swig_callbackOnChildAdd = callbackOnChildAdd;
2391   swig_callbackOnChildRemove = callbackOnChildRemove;
2392   swig_callbackOnPropertySet = callbackOnPropertySet;
2393   swig_callbackOnSizeSet = callbackOnSizeSet;
2394   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2395   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2396   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2397   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2398   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2399   swig_callbackOnRelayout = callbackOnRelayout;
2400   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2401   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2402   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2403   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2404   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2405   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2406   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2407   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2408   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2409   swig_callbackOnInitialize = callbackOnInitialize;
2410   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2411   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2412   swig_callbackOnStyleChange = callbackOnStyleChange;
2413   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2414   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2415   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2416   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2417   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2418   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2419   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2420   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2421   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2422   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2423   swig_callbackOnPinch = callbackOnPinch;
2424   swig_callbackOnPan = callbackOnPan;
2425   swig_callbackOnTap = callbackOnTap;
2426   swig_callbackOnLongPress = callbackOnLongPress;
2427   swig_callbackSignalConnected = callbackSignalConnected;
2428   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2429 }
2430
2431 void SwigDirector_ViewImpl::swig_init_callbacks() {
2432   swig_callbackOnStageConnection = 0;
2433   swig_callbackOnStageDisconnection = 0;
2434   swig_callbackOnChildAdd = 0;
2435   swig_callbackOnChildRemove = 0;
2436   swig_callbackOnPropertySet = 0;
2437   swig_callbackOnSizeSet = 0;
2438   swig_callbackOnSizeAnimation = 0;
2439   swig_callbackOnTouchEvent = 0;
2440   swig_callbackOnHoverEvent = 0;
2441   swig_callbackOnKeyEvent = 0;
2442   swig_callbackOnWheelEvent = 0;
2443   swig_callbackOnRelayout = 0;
2444   swig_callbackOnSetResizePolicy = 0;
2445   swig_callbackGetNaturalSize = 0;
2446   swig_callbackCalculateChildSize = 0;
2447   swig_callbackGetHeightForWidth = 0;
2448   swig_callbackGetWidthForHeight = 0;
2449   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2450   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2451   swig_callbackOnCalculateRelayoutSize = 0;
2452   swig_callbackOnLayoutNegotiated = 0;
2453   swig_callbackOnInitialize = 0;
2454   swig_callbackOnControlChildAdd = 0;
2455   swig_callbackOnControlChildRemove = 0;
2456   swig_callbackOnStyleChange = 0;
2457   swig_callbackOnAccessibilityActivated = 0;
2458   swig_callbackOnAccessibilityPan = 0;
2459   swig_callbackOnAccessibilityTouch = 0;
2460   swig_callbackOnAccessibilityValueChange = 0;
2461   swig_callbackOnAccessibilityZoom = 0;
2462   swig_callbackOnKeyInputFocusGained = 0;
2463   swig_callbackOnKeyInputFocusLost = 0;
2464   swig_callbackGetNextKeyboardFocusableActor = 0;
2465   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2466   swig_callbackOnKeyboardEnter = 0;
2467   swig_callbackOnPinch = 0;
2468   swig_callbackOnPan = 0;
2469   swig_callbackOnTap = 0;
2470   swig_callbackOnLongPress = 0;
2471   swig_callbackSignalConnected = 0;
2472   swig_callbackSignalDisconnected = 0;
2473 }
2474
2475 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2476   swig_init_callbacks();
2477 }
2478
2479 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2480
2481 }
2482
2483
2484 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2485   unsigned int c_result = SwigValueInit< unsigned int >() ;
2486   unsigned int jresult = 0 ;
2487
2488   if (!swig_callbackGetNumberOfItems) {
2489     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2490   } else {
2491     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2492     c_result = (unsigned int)jresult;
2493   }
2494   return c_result;
2495 }
2496
2497 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2498   Dali::Actor c_result ;
2499   void * jresult = 0 ;
2500   unsigned int jitemId  ;
2501
2502   if (!swig_callbackNewItem) {
2503     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2504   } else {
2505     jitemId = itemId;
2506     jresult = (void *) swig_callbackNewItem(jitemId);
2507     if (!jresult) {
2508       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2509       return c_result;
2510     }
2511     c_result = *(Dali::Actor *)jresult;
2512   }
2513   return c_result;
2514 }
2515
2516 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2517   unsigned int jitemId  ;
2518   void * jactor  ;
2519
2520   if (!swig_callbackItemReleased) {
2521     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2522     return;
2523   } else {
2524     jitemId = itemId;
2525     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2526     swig_callbackItemReleased(jitemId, jactor);
2527   }
2528 }
2529
2530 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2531   return Dali::Toolkit::ItemFactory::GetExtension();
2532 }
2533
2534 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2535   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2536   swig_callbackNewItem = callbackNewItem;
2537   swig_callbackItemReleased = callbackItemReleased;
2538 }
2539
2540 void SwigDirector_ItemFactory::swig_init_callbacks() {
2541   swig_callbackGetNumberOfItems = 0;
2542   swig_callbackNewItem = 0;
2543   swig_callbackItemReleased = 0;
2544 }
2545
2546 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2547   swig_init_callbacks();
2548 }
2549
2550 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2551
2552 }
2553
2554
2555 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2556   Dali::Actor c_result ;
2557   void * jresult = 0 ;
2558   void * jcurrent  ;
2559   void * jproposed  ;
2560   int jdirection  ;
2561
2562   if (!swig_callbackGetNextFocusableActor) {
2563     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2564   } else {
2565     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2566     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2567     jdirection = (int)direction;
2568     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2569     if (!jresult) {
2570       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2571       return c_result;
2572     }
2573     c_result = *(Dali::Actor *)jresult;
2574   }
2575   return c_result;
2576 }
2577
2578 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2579   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2580 }
2581
2582 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2583   swig_callbackGetNextFocusableActor = 0;
2584 }
2585
2586
2587 #ifdef __cplusplus
2588 extern "C" {
2589 #endif
2590
2591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2592   void * jresult ;
2593   floatp *result = 0 ;
2594
2595   {
2596     try {
2597       result = (floatp *)new_floatp();
2598     } catch (std::out_of_range& e) {
2599       {
2600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2601       };
2602     } catch (std::exception& e) {
2603       {
2604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2605       };
2606     } catch (DaliException e) {
2607       {
2608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2609       };
2610     } catch (...) {
2611       {
2612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2613       };
2614     }
2615   }
2616   jresult = (void *)result;
2617   return jresult;
2618 }
2619
2620
2621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2622   floatp *arg1 = (floatp *) 0 ;
2623
2624   arg1 = (floatp *)jarg1;
2625   {
2626     try {
2627       delete_floatp(arg1);
2628     } catch (std::out_of_range& e) {
2629       {
2630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2631       };
2632     } catch (std::exception& e) {
2633       {
2634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2635       };
2636     } catch (Dali::DaliException e) {
2637       {
2638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2639       };
2640     } catch (...) {
2641       {
2642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2643       };
2644     }
2645   }
2646
2647 }
2648
2649
2650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2651   floatp *arg1 = (floatp *) 0 ;
2652   float arg2 ;
2653
2654   arg1 = (floatp *)jarg1;
2655   arg2 = (float)jarg2;
2656   {
2657     try {
2658       floatp_assign(arg1,arg2);
2659     } catch (std::out_of_range& e) {
2660       {
2661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2662       };
2663     } catch (std::exception& e) {
2664       {
2665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2666       };
2667     } catch (Dali::DaliException e) {
2668       {
2669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2670       };
2671     } catch (...) {
2672       {
2673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2674       };
2675     }
2676   }
2677
2678 }
2679
2680
2681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2682   float jresult ;
2683   floatp *arg1 = (floatp *) 0 ;
2684   float result;
2685
2686   arg1 = (floatp *)jarg1;
2687   {
2688     try {
2689       result = (float)floatp_value(arg1);
2690     } catch (std::out_of_range& e) {
2691       {
2692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2693       };
2694     } catch (std::exception& e) {
2695       {
2696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2697       };
2698     } catch (DaliException e) {
2699       {
2700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2701       };
2702     } catch (...) {
2703       {
2704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2705       };
2706     }
2707   }
2708   jresult = result;
2709   return jresult;
2710 }
2711
2712
2713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2714   void * jresult ;
2715   floatp *arg1 = (floatp *) 0 ;
2716   float *result = 0 ;
2717
2718   arg1 = (floatp *)jarg1;
2719   {
2720     try {
2721       result = (float *)floatp_cast(arg1);
2722     } catch (std::out_of_range& e) {
2723       {
2724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2725       };
2726     } catch (std::exception& e) {
2727       {
2728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2729       };
2730     } catch (Dali::DaliException e) {
2731       {
2732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2733       };
2734     } catch (...) {
2735       {
2736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2737       };
2738     }
2739   }
2740
2741   jresult = (void *)result;
2742   return jresult;
2743 }
2744
2745
2746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2747   void * jresult ;
2748   float *arg1 = (float *) 0 ;
2749   floatp *result = 0 ;
2750
2751   arg1 = (float *)jarg1;
2752   {
2753     try {
2754       result = (floatp *)floatp_frompointer(arg1);
2755     } catch (std::out_of_range& e) {
2756       {
2757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2758       };
2759     } catch (std::exception& e) {
2760       {
2761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2762       };
2763     } catch (Dali::DaliException e) {
2764       {
2765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2766       };
2767     } catch (...) {
2768       {
2769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2770       };
2771     }
2772   }
2773
2774   jresult = (void *)result;
2775   return jresult;
2776 }
2777
2778
2779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2780   void * jresult ;
2781   intp *result = 0 ;
2782
2783   {
2784     try {
2785       result = (intp *)new_intp();
2786     } catch (std::out_of_range& e) {
2787       {
2788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2789       };
2790     } catch (std::exception& e) {
2791       {
2792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2793       };
2794     } catch (Dali::DaliException e) {
2795       {
2796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2797       };
2798     } catch (...) {
2799       {
2800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2801       };
2802     }
2803   }
2804
2805   jresult = (void *)result;
2806   return jresult;
2807 }
2808
2809
2810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2811   intp *arg1 = (intp *) 0 ;
2812
2813   arg1 = (intp *)jarg1;
2814   {
2815     try {
2816       delete_intp(arg1);
2817     } catch (std::out_of_range& e) {
2818       {
2819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2820       };
2821     } catch (std::exception& e) {
2822       {
2823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2824       };
2825     } catch (Dali::DaliException e) {
2826       {
2827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2828       };
2829     } catch (...) {
2830       {
2831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2832       };
2833     }
2834   }
2835
2836 }
2837
2838
2839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2840   intp *arg1 = (intp *) 0 ;
2841   int arg2 ;
2842
2843   arg1 = (intp *)jarg1;
2844   arg2 = (int)jarg2;
2845   {
2846     try {
2847       intp_assign(arg1,arg2);
2848     } catch (std::out_of_range& e) {
2849       {
2850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2851       };
2852     } catch (std::exception& e) {
2853       {
2854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2855       };
2856     } catch (Dali::DaliException e) {
2857       {
2858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2859       };
2860     } catch (...) {
2861       {
2862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2863       };
2864     }
2865   }
2866
2867 }
2868
2869
2870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2871   int jresult ;
2872   intp *arg1 = (intp *) 0 ;
2873   int result;
2874
2875   arg1 = (intp *)jarg1;
2876   {
2877     try {
2878       result = (int)intp_value(arg1);
2879     } catch (std::out_of_range& e) {
2880       {
2881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2882       };
2883     } catch (std::exception& e) {
2884       {
2885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2886       };
2887     } catch (Dali::DaliException e) {
2888       {
2889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2890       };
2891     } catch (...) {
2892       {
2893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2894       };
2895     }
2896   }
2897
2898   jresult = result;
2899   return jresult;
2900 }
2901
2902
2903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2904   void * jresult ;
2905   intp *arg1 = (intp *) 0 ;
2906   int *result = 0 ;
2907
2908   arg1 = (intp *)jarg1;
2909   {
2910     try {
2911       result = (int *)intp_cast(arg1);
2912     } catch (std::out_of_range& e) {
2913       {
2914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2915       };
2916     } catch (std::exception& e) {
2917       {
2918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2919       };
2920     } catch (Dali::DaliException e) {
2921       {
2922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2923       };
2924     } catch (...) {
2925       {
2926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2927       };
2928     }
2929   }
2930
2931   jresult = (void *)result;
2932   return jresult;
2933 }
2934
2935
2936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2937   void * jresult ;
2938   int *arg1 = (int *) 0 ;
2939   intp *result = 0 ;
2940
2941   arg1 = (int *)jarg1;
2942   {
2943     try {
2944       result = (intp *)intp_frompointer(arg1);
2945     } catch (std::out_of_range& e) {
2946       {
2947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2948       };
2949     } catch (std::exception& e) {
2950       {
2951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2952       };
2953     } catch (Dali::DaliException e) {
2954       {
2955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2956       };
2957     } catch (...) {
2958       {
2959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2960       };
2961     }
2962   }
2963
2964   jresult = (void *)result;
2965   return jresult;
2966 }
2967
2968
2969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2970   void * jresult ;
2971   doublep *result = 0 ;
2972
2973   {
2974     try {
2975       result = (doublep *)new_doublep();
2976     } catch (std::out_of_range& e) {
2977       {
2978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2979       };
2980     } catch (std::exception& e) {
2981       {
2982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2983       };
2984     } catch (Dali::DaliException e) {
2985       {
2986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2987       };
2988     } catch (...) {
2989       {
2990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2991       };
2992     }
2993   }
2994
2995   jresult = (void *)result;
2996   return jresult;
2997 }
2998
2999
3000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3001   doublep *arg1 = (doublep *) 0 ;
3002
3003   arg1 = (doublep *)jarg1;
3004   {
3005     try {
3006       delete_doublep(arg1);
3007     } catch (std::out_of_range& e) {
3008       {
3009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3010       };
3011     } catch (std::exception& e) {
3012       {
3013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3014       };
3015     } catch (Dali::DaliException e) {
3016       {
3017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3018       };
3019     } catch (...) {
3020       {
3021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3022       };
3023     }
3024   }
3025
3026 }
3027
3028
3029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3030   doublep *arg1 = (doublep *) 0 ;
3031   double arg2 ;
3032
3033   arg1 = (doublep *)jarg1;
3034   arg2 = (double)jarg2;
3035   {
3036     try {
3037       doublep_assign(arg1,arg2);
3038     } catch (std::out_of_range& e) {
3039       {
3040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3041       };
3042     } catch (std::exception& e) {
3043       {
3044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3045       };
3046     } catch (Dali::DaliException e) {
3047       {
3048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3049       };
3050     } catch (...) {
3051       {
3052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3053       };
3054     }
3055   }
3056
3057 }
3058
3059
3060 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3061   double jresult ;
3062   doublep *arg1 = (doublep *) 0 ;
3063   double result;
3064
3065   arg1 = (doublep *)jarg1;
3066   {
3067     try {
3068       result = (double)doublep_value(arg1);
3069     } catch (std::out_of_range& e) {
3070       {
3071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3072       };
3073     } catch (std::exception& e) {
3074       {
3075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3076       };
3077     } catch (Dali::DaliException e) {
3078       {
3079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3080       };
3081     } catch (...) {
3082       {
3083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3084       };
3085     }
3086   }
3087
3088   jresult = result;
3089   return jresult;
3090 }
3091
3092
3093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3094   void * jresult ;
3095   doublep *arg1 = (doublep *) 0 ;
3096   double *result = 0 ;
3097
3098   arg1 = (doublep *)jarg1;
3099   {
3100     try {
3101       result = (double *)doublep_cast(arg1);
3102     } catch (std::out_of_range& e) {
3103       {
3104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3105       };
3106     } catch (std::exception& e) {
3107       {
3108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3109       };
3110     } catch (Dali::DaliException e) {
3111       {
3112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3113       };
3114     } catch (...) {
3115       {
3116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3117       };
3118     }
3119   }
3120
3121   jresult = (void *)result;
3122   return jresult;
3123 }
3124
3125
3126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3127   void * jresult ;
3128   double *arg1 = (double *) 0 ;
3129   doublep *result = 0 ;
3130
3131   arg1 = (double *)jarg1;
3132   {
3133     try {
3134       result = (doublep *)doublep_frompointer(arg1);
3135     } catch (std::out_of_range& e) {
3136       {
3137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3138       };
3139     } catch (std::exception& e) {
3140       {
3141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3142       };
3143     } catch (Dali::DaliException e) {
3144       {
3145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3146       };
3147     } catch (...) {
3148       {
3149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3150       };
3151     }
3152   }
3153
3154   jresult = (void *)result;
3155   return jresult;
3156 }
3157
3158
3159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3160   void * jresult ;
3161   uintp *result = 0 ;
3162
3163   {
3164     try {
3165       result = (uintp *)new_uintp();
3166     } catch (std::out_of_range& e) {
3167       {
3168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3169       };
3170     } catch (std::exception& e) {
3171       {
3172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3173       };
3174     } catch (Dali::DaliException e) {
3175       {
3176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3177       };
3178     } catch (...) {
3179       {
3180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3181       };
3182     }
3183   }
3184
3185   jresult = (void *)result;
3186   return jresult;
3187 }
3188
3189
3190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3191   uintp *arg1 = (uintp *) 0 ;
3192
3193   arg1 = (uintp *)jarg1;
3194   {
3195     try {
3196       delete_uintp(arg1);
3197     } catch (std::out_of_range& e) {
3198       {
3199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3200       };
3201     } catch (std::exception& e) {
3202       {
3203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3204       };
3205     } catch (Dali::DaliException e) {
3206       {
3207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3208       };
3209     } catch (...) {
3210       {
3211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3212       };
3213     }
3214   }
3215
3216 }
3217
3218
3219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3220   uintp *arg1 = (uintp *) 0 ;
3221   unsigned int arg2 ;
3222
3223   arg1 = (uintp *)jarg1;
3224   arg2 = (unsigned int)jarg2;
3225   {
3226     try {
3227       uintp_assign(arg1,arg2);
3228     } catch (std::out_of_range& e) {
3229       {
3230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3231       };
3232     } catch (std::exception& e) {
3233       {
3234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3235       };
3236     } catch (Dali::DaliException e) {
3237       {
3238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3239       };
3240     } catch (...) {
3241       {
3242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3243       };
3244     }
3245   }
3246
3247 }
3248
3249
3250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3251   unsigned int jresult ;
3252   uintp *arg1 = (uintp *) 0 ;
3253   unsigned int result;
3254
3255   arg1 = (uintp *)jarg1;
3256   {
3257     try {
3258       result = (unsigned int)uintp_value(arg1);
3259     } catch (std::out_of_range& e) {
3260       {
3261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3262       };
3263     } catch (std::exception& e) {
3264       {
3265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3266       };
3267     } catch (Dali::DaliException e) {
3268       {
3269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3270       };
3271     } catch (...) {
3272       {
3273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3274       };
3275     }
3276   }
3277
3278   jresult = result;
3279   return jresult;
3280 }
3281
3282
3283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3284   void * jresult ;
3285   uintp *arg1 = (uintp *) 0 ;
3286   unsigned int *result = 0 ;
3287
3288   arg1 = (uintp *)jarg1;
3289   {
3290     try {
3291       result = (unsigned int *)uintp_cast(arg1);
3292     } catch (std::out_of_range& e) {
3293       {
3294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (std::exception& e) {
3297       {
3298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3299       };
3300     } catch (Dali::DaliException e) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3303       };
3304     } catch (...) {
3305       {
3306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3307       };
3308     }
3309   }
3310
3311   jresult = (void *)result;
3312   return jresult;
3313 }
3314
3315
3316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3317   void * jresult ;
3318   unsigned int *arg1 = (unsigned int *) 0 ;
3319   uintp *result = 0 ;
3320
3321   arg1 = (unsigned int *)jarg1;
3322   {
3323     try {
3324       result = (uintp *)uintp_frompointer(arg1);
3325     } catch (std::out_of_range& e) {
3326       {
3327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3328       };
3329     } catch (std::exception& e) {
3330       {
3331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3332       };
3333     } catch (Dali::DaliException e) {
3334       {
3335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3336       };
3337     } catch (...) {
3338       {
3339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3340       };
3341     }
3342   }
3343
3344   jresult = (void *)result;
3345   return jresult;
3346 }
3347
3348
3349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3350   void * jresult ;
3351   ushortp *result = 0 ;
3352
3353   {
3354     try {
3355       result = (ushortp *)new_ushortp();
3356     } catch (std::out_of_range& e) {
3357       {
3358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3359       };
3360     } catch (std::exception& e) {
3361       {
3362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3363       };
3364     } catch (Dali::DaliException e) {
3365       {
3366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3367       };
3368     } catch (...) {
3369       {
3370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3371       };
3372     }
3373   }
3374
3375   jresult = (void *)result;
3376   return jresult;
3377 }
3378
3379
3380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3381   ushortp *arg1 = (ushortp *) 0 ;
3382
3383   arg1 = (ushortp *)jarg1;
3384   {
3385     try {
3386       delete_ushortp(arg1);
3387     } catch (std::out_of_range& e) {
3388       {
3389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3390       };
3391     } catch (std::exception& e) {
3392       {
3393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3394       };
3395     } catch (Dali::DaliException e) {
3396       {
3397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3398       };
3399     } catch (...) {
3400       {
3401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3402       };
3403     }
3404   }
3405
3406 }
3407
3408
3409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3410   ushortp *arg1 = (ushortp *) 0 ;
3411   unsigned short arg2 ;
3412
3413   arg1 = (ushortp *)jarg1;
3414   arg2 = (unsigned short)jarg2;
3415   {
3416     try {
3417       ushortp_assign(arg1,arg2);
3418     } catch (std::out_of_range& e) {
3419       {
3420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3421       };
3422     } catch (std::exception& e) {
3423       {
3424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3425       };
3426     } catch (Dali::DaliException e) {
3427       {
3428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3429       };
3430     } catch (...) {
3431       {
3432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3433       };
3434     }
3435   }
3436
3437 }
3438
3439
3440 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3441   unsigned short jresult ;
3442   ushortp *arg1 = (ushortp *) 0 ;
3443   unsigned short result;
3444
3445   arg1 = (ushortp *)jarg1;
3446   {
3447     try {
3448       result = (unsigned short)ushortp_value(arg1);
3449     } catch (std::out_of_range& e) {
3450       {
3451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3452       };
3453     } catch (std::exception& e) {
3454       {
3455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3456       };
3457     } catch (Dali::DaliException e) {
3458       {
3459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3460       };
3461     } catch (...) {
3462       {
3463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3464       };
3465     }
3466   }
3467
3468   jresult = result;
3469   return jresult;
3470 }
3471
3472
3473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3474   void * jresult ;
3475   ushortp *arg1 = (ushortp *) 0 ;
3476   unsigned short *result = 0 ;
3477
3478   arg1 = (ushortp *)jarg1;
3479   {
3480     try {
3481       result = (unsigned short *)ushortp_cast(arg1);
3482     } catch (std::out_of_range& e) {
3483       {
3484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3485       };
3486     } catch (std::exception& e) {
3487       {
3488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3489       };
3490     } catch (Dali::DaliException e) {
3491       {
3492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3493       };
3494     } catch (...) {
3495       {
3496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3497       };
3498     }
3499   }
3500
3501   jresult = (void *)result;
3502   return jresult;
3503 }
3504
3505
3506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3507   void * jresult ;
3508   unsigned short *arg1 = (unsigned short *) 0 ;
3509   ushortp *result = 0 ;
3510
3511   arg1 = (unsigned short *)jarg1;
3512   {
3513     try {
3514       result = (ushortp *)ushortp_frompointer(arg1);
3515     } catch (std::out_of_range& e) {
3516       {
3517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3518       };
3519     } catch (std::exception& e) {
3520       {
3521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3522       };
3523     } catch (Dali::DaliException e) {
3524       {
3525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3526       };
3527     } catch (...) {
3528       {
3529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3530       };
3531     }
3532   }
3533
3534   jresult = (void *)result;
3535   return jresult;
3536 }
3537
3538
3539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3540   unsigned int jresult ;
3541   int arg1 ;
3542   unsigned int result;
3543
3544   arg1 = (int)jarg1;
3545   {
3546     try {
3547       result = (unsigned int)int_to_uint(arg1);
3548     } catch (std::out_of_range& e) {
3549       {
3550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3551       };
3552     } catch (std::exception& e) {
3553       {
3554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3555       };
3556     } catch (Dali::DaliException e) {
3557       {
3558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3559       };
3560     } catch (...) {
3561       {
3562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3563       };
3564     }
3565   }
3566
3567   jresult = result;
3568   return jresult;
3569 }
3570
3571
3572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3573   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3574
3575   arg1 = (Dali::RefObject *)jarg1;
3576   {
3577     try {
3578       (arg1)->Reference();
3579     } catch (std::out_of_range& e) {
3580       {
3581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3582       };
3583     } catch (std::exception& e) {
3584       {
3585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3586       };
3587     } catch (Dali::DaliException e) {
3588       {
3589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3590       };
3591     } catch (...) {
3592       {
3593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3594       };
3595     }
3596   }
3597
3598 }
3599
3600
3601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3602   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3603
3604   arg1 = (Dali::RefObject *)jarg1;
3605   {
3606     try {
3607       (arg1)->Unreference();
3608     } catch (std::out_of_range& e) {
3609       {
3610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3611       };
3612     } catch (std::exception& e) {
3613       {
3614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3615       };
3616     } catch (Dali::DaliException e) {
3617       {
3618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3619       };
3620     } catch (...) {
3621       {
3622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3623       };
3624     }
3625   }
3626
3627 }
3628
3629
3630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3631   int jresult ;
3632   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3633   int result;
3634
3635   arg1 = (Dali::RefObject *)jarg1;
3636   {
3637     try {
3638       result = (int)(arg1)->ReferenceCount();
3639     } catch (std::out_of_range& e) {
3640       {
3641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3642       };
3643     } catch (std::exception& e) {
3644       {
3645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3646       };
3647     } catch (Dali::DaliException e) {
3648       {
3649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3650       };
3651     } catch (...) {
3652       {
3653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3654       };
3655     }
3656   }
3657
3658   jresult = result;
3659   return jresult;
3660 }
3661
3662
3663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3664   void * jresult ;
3665   Dali::Any *result = 0 ;
3666
3667   {
3668     try {
3669       result = (Dali::Any *)new Dali::Any();
3670     } catch (std::out_of_range& e) {
3671       {
3672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3673       };
3674     } catch (std::exception& e) {
3675       {
3676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3677       };
3678     } catch (Dali::DaliException e) {
3679       {
3680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3681       };
3682     } catch (...) {
3683       {
3684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3685       };
3686     }
3687   }
3688
3689   jresult = (void *)result;
3690   return jresult;
3691 }
3692
3693
3694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3695   Dali::Any *arg1 = (Dali::Any *) 0 ;
3696
3697   arg1 = (Dali::Any *)jarg1;
3698   {
3699     try {
3700       delete arg1;
3701     } catch (std::out_of_range& e) {
3702       {
3703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3704       };
3705     } catch (std::exception& e) {
3706       {
3707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3708       };
3709     } catch (Dali::DaliException e) {
3710       {
3711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3712       };
3713     } catch (...) {
3714       {
3715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3716       };
3717     }
3718   }
3719
3720 }
3721
3722
3723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3724   char *arg1 = (char *) 0 ;
3725
3726   arg1 = (char *)jarg1;
3727   {
3728     try {
3729       Dali::Any::AssertAlways((char const *)arg1);
3730     } catch (std::out_of_range& e) {
3731       {
3732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3733       };
3734     } catch (std::exception& e) {
3735       {
3736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3737       };
3738     } catch (Dali::DaliException e) {
3739       {
3740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3741       };
3742     } catch (...) {
3743       {
3744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3745       };
3746     }
3747   }
3748
3749 }
3750
3751
3752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3753   void * jresult ;
3754   Dali::Any *arg1 = 0 ;
3755   Dali::Any *result = 0 ;
3756
3757   arg1 = (Dali::Any *)jarg1;
3758   if (!arg1) {
3759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3760     return 0;
3761   }
3762   {
3763     try {
3764       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3765     } catch (std::out_of_range& e) {
3766       {
3767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3768       };
3769     } catch (std::exception& e) {
3770       {
3771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3772       };
3773     } catch (Dali::DaliException e) {
3774       {
3775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3776       };
3777     } catch (...) {
3778       {
3779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3780       };
3781     }
3782   }
3783
3784   jresult = (void *)result;
3785   return jresult;
3786 }
3787
3788
3789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3790   void * jresult ;
3791   Dali::Any *arg1 = (Dali::Any *) 0 ;
3792   Dali::Any *arg2 = 0 ;
3793   Dali::Any *result = 0 ;
3794
3795   arg1 = (Dali::Any *)jarg1;
3796   arg2 = (Dali::Any *)jarg2;
3797   if (!arg2) {
3798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3799     return 0;
3800   }
3801   {
3802     try {
3803       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3804     } catch (std::out_of_range& e) {
3805       {
3806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3807       };
3808     } catch (std::exception& e) {
3809       {
3810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3811       };
3812     } catch (Dali::DaliException e) {
3813       {
3814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3815       };
3816     } catch (...) {
3817       {
3818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3819       };
3820     }
3821   }
3822
3823   jresult = (void *)result;
3824   return jresult;
3825 }
3826
3827
3828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3829   void * jresult ;
3830   Dali::Any *arg1 = (Dali::Any *) 0 ;
3831   std::type_info *result = 0 ;
3832
3833   arg1 = (Dali::Any *)jarg1;
3834   {
3835     try {
3836       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3837     } catch (std::out_of_range& e) {
3838       {
3839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3840       };
3841     } catch (std::exception& e) {
3842       {
3843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3844       };
3845     } catch (Dali::DaliException e) {
3846       {
3847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3848       };
3849     } catch (...) {
3850       {
3851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3852       };
3853     }
3854   }
3855
3856   jresult = (void *)result;
3857   return jresult;
3858 }
3859
3860
3861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3862   unsigned int jresult ;
3863   Dali::Any *arg1 = (Dali::Any *) 0 ;
3864   bool result;
3865
3866   arg1 = (Dali::Any *)jarg1;
3867   {
3868     try {
3869       result = (bool)((Dali::Any const *)arg1)->Empty();
3870     } catch (std::out_of_range& e) {
3871       {
3872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3873       };
3874     } catch (std::exception& e) {
3875       {
3876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3877       };
3878     } catch (Dali::DaliException e) {
3879       {
3880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3881       };
3882     } catch (...) {
3883       {
3884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3885       };
3886     }
3887   }
3888
3889   jresult = result;
3890   return jresult;
3891 }
3892
3893
3894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3895   void * jresult ;
3896   std::type_info *arg1 = 0 ;
3897   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3898   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3899   Dali::Any::AnyContainerBase *result = 0 ;
3900
3901   arg1 = (std::type_info *)jarg1;
3902   if (!arg1) {
3903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3904     return 0;
3905   }
3906   arg2 = (Dali::Any::CloneFunc)jarg2;
3907   arg3 = (Dali::Any::DeleteFunc)jarg3;
3908   {
3909     try {
3910       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3911     } catch (std::out_of_range& e) {
3912       {
3913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3914       };
3915     } catch (std::exception& e) {
3916       {
3917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3918       };
3919     } catch (Dali::DaliException e) {
3920       {
3921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3922       };
3923     } catch (...) {
3924       {
3925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3926       };
3927     }
3928   }
3929
3930   jresult = (void *)result;
3931   return jresult;
3932 }
3933
3934
3935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3936   void * jresult ;
3937   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3938   std::type_info *result = 0 ;
3939
3940   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3941   {
3942     try {
3943       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3944     } catch (std::out_of_range& e) {
3945       {
3946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3947       };
3948     } catch (std::exception& e) {
3949       {
3950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3951       };
3952     } catch (Dali::DaliException e) {
3953       {
3954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3955       };
3956     } catch (...) {
3957       {
3958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3959       };
3960     }
3961   }
3962
3963   jresult = (void *)result;
3964   return jresult;
3965 }
3966
3967
3968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3969   void * jresult ;
3970   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3971   ::std::type_info *result = 0 ;
3972
3973   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3974   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3975   jresult = (void *)result;
3976   return jresult;
3977 }
3978
3979
3980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3981   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3982   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3983
3984   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3985   arg2 = (Dali::Any::CloneFunc)jarg2;
3986   if (arg1) (arg1)->mCloneFunc = arg2;
3987 }
3988
3989
3990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3991   void * jresult ;
3992   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3993   Dali::Any::CloneFunc result;
3994
3995   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3996   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3997   jresult = (void *)result;
3998   return jresult;
3999 }
4000
4001
4002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4003   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4004   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4005
4006   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4007   arg2 = (Dali::Any::DeleteFunc)jarg2;
4008   if (arg1) (arg1)->mDeleteFunc = arg2;
4009 }
4010
4011
4012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4013   void * jresult ;
4014   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4015   Dali::Any::DeleteFunc result;
4016
4017   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4018   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4019   jresult = (void *)result;
4020   return jresult;
4021 }
4022
4023
4024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4025   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4026
4027   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4028   {
4029     try {
4030       delete arg1;
4031     } catch (std::out_of_range& e) {
4032       {
4033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4034       };
4035     } catch (std::exception& e) {
4036       {
4037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4038       };
4039     } catch (Dali::DaliException e) {
4040       {
4041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4042       };
4043     } catch (...) {
4044       {
4045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4046       };
4047     }
4048   }
4049
4050 }
4051
4052
4053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4054   Dali::Any *arg1 = (Dali::Any *) 0 ;
4055   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4056
4057   arg1 = (Dali::Any *)jarg1;
4058   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4059   if (arg1) (arg1)->mContainer = arg2;
4060 }
4061
4062
4063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4064   void * jresult ;
4065   Dali::Any *arg1 = (Dali::Any *) 0 ;
4066   Dali::Any::AnyContainerBase *result = 0 ;
4067
4068   arg1 = (Dali::Any *)jarg1;
4069   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4070   jresult = (void *)result;
4071   return jresult;
4072 }
4073
4074
4075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4076   char *arg1 = (char *) 0 ;
4077   char *arg2 = (char *) 0 ;
4078
4079   arg1 = (char *)jarg1;
4080   arg2 = (char *)jarg2;
4081   {
4082     try {
4083       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4084     } catch (std::out_of_range& e) {
4085       {
4086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4087       };
4088     } catch (std::exception& e) {
4089       {
4090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4091       };
4092     } catch (Dali::DaliException e) {
4093       {
4094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4095       };
4096     } catch (...) {
4097       {
4098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4099       };
4100     }
4101   }
4102
4103 }
4104
4105
4106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4107   void * jresult ;
4108   char *arg1 = (char *) 0 ;
4109   char *arg2 = (char *) 0 ;
4110   Dali::DaliException *result = 0 ;
4111
4112   arg1 = (char *)jarg1;
4113   arg2 = (char *)jarg2;
4114   {
4115     try {
4116       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4117     } catch (std::out_of_range& e) {
4118       {
4119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4120       };
4121     } catch (std::exception& e) {
4122       {
4123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4124       };
4125     } catch (Dali::DaliException e) {
4126       {
4127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4128       };
4129     } catch (...) {
4130       {
4131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4132       };
4133     }
4134   }
4135
4136   jresult = (void *)result;
4137   return jresult;
4138 }
4139
4140
4141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4142   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4143   std::string arg2 = std::string(jarg2);
4144
4145   arg1 = (Dali::DaliException *)jarg1;
4146   {
4147     if (!arg2.empty()) {
4148       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4149     } else {
4150       arg1->location = 0;
4151     }
4152   }
4153 }
4154
4155 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4156   char * jresult ;
4157   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4158   char *result = 0 ;
4159
4160   arg1 = (Dali::DaliException *)jarg1;
4161   result = (char *) ((arg1)->location);
4162   jresult = SWIG_csharp_string_callback((const char *)result);
4163   return jresult;
4164 }
4165
4166
4167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4168   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4169   std::string arg2 = std::string(jarg2);
4170
4171   arg1 = (Dali::DaliException *)jarg1;
4172   {
4173     if (!arg2.empty()) {
4174       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4175     } else {
4176       arg1->condition = 0;
4177     }
4178   }
4179 }
4180
4181
4182 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4183   char * jresult ;
4184   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4185   char *result = 0 ;
4186
4187   arg1 = (Dali::DaliException *)jarg1;
4188   result = (char *) ((arg1)->condition);
4189   jresult = SWIG_csharp_string_callback((const char *)result);
4190   return jresult;
4191 }
4192
4193
4194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4195   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4196
4197   arg1 = (Dali::DaliException *)jarg1;
4198   {
4199     try {
4200       delete arg1;
4201     } catch (std::out_of_range& e) {
4202       {
4203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4204       };
4205     } catch (std::exception& e) {
4206       {
4207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4208       };
4209     } catch (Dali::DaliException e) {
4210       {
4211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4212       };
4213     } catch (...) {
4214       {
4215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4216       };
4217     }
4218   }
4219
4220 }
4221
4222
4223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4224   void * jresult ;
4225   Dali::Vector2 *result = 0 ;
4226
4227   {
4228     try {
4229       result = (Dali::Vector2 *)new Dali::Vector2();
4230     } catch (std::out_of_range& e) {
4231       {
4232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4233       };
4234     } catch (std::exception& e) {
4235       {
4236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4237       };
4238     } catch (Dali::DaliException e) {
4239       {
4240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4241       };
4242     } catch (...) {
4243       {
4244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4245       };
4246     }
4247   }
4248
4249   jresult = (void *)result;
4250   return jresult;
4251 }
4252
4253
4254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4255   void * jresult ;
4256   float arg1 ;
4257   float arg2 ;
4258   Dali::Vector2 *result = 0 ;
4259
4260   arg1 = (float)jarg1;
4261   arg2 = (float)jarg2;
4262   {
4263     try {
4264       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4265     } catch (std::out_of_range& e) {
4266       {
4267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4268       };
4269     } catch (std::exception& e) {
4270       {
4271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4272       };
4273     } catch (Dali::DaliException e) {
4274       {
4275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4276       };
4277     } catch (...) {
4278       {
4279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4280       };
4281     }
4282   }
4283
4284   jresult = (void *)result;
4285   return jresult;
4286 }
4287
4288
4289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4290   void * jresult ;
4291   float *arg1 = (float *) 0 ;
4292   Dali::Vector2 *result = 0 ;
4293
4294   arg1 = jarg1;
4295   {
4296     try {
4297       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4298     } catch (std::out_of_range& e) {
4299       {
4300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4301       };
4302     } catch (std::exception& e) {
4303       {
4304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4305       };
4306     } catch (Dali::DaliException e) {
4307       {
4308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4309       };
4310     } catch (...) {
4311       {
4312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4313       };
4314     }
4315   }
4316
4317   jresult = (void *)result;
4318
4319
4320   return jresult;
4321 }
4322
4323
4324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4325   void * jresult ;
4326   Dali::Vector3 *arg1 = 0 ;
4327   Dali::Vector2 *result = 0 ;
4328
4329   arg1 = (Dali::Vector3 *)jarg1;
4330   if (!arg1) {
4331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4332     return 0;
4333   }
4334   {
4335     try {
4336       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4337     } catch (std::out_of_range& e) {
4338       {
4339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4340       };
4341     } catch (std::exception& e) {
4342       {
4343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4344       };
4345     } catch (Dali::DaliException e) {
4346       {
4347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4348       };
4349     } catch (...) {
4350       {
4351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4352       };
4353     }
4354   }
4355
4356   jresult = (void *)result;
4357   return jresult;
4358 }
4359
4360
4361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4362   void * jresult ;
4363   Dali::Vector4 *arg1 = 0 ;
4364   Dali::Vector2 *result = 0 ;
4365
4366   arg1 = (Dali::Vector4 *)jarg1;
4367   if (!arg1) {
4368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4369     return 0;
4370   }
4371   {
4372     try {
4373       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4374     } catch (std::out_of_range& e) {
4375       {
4376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4377       };
4378     } catch (std::exception& e) {
4379       {
4380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4381       };
4382     } catch (Dali::DaliException e) {
4383       {
4384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4385       };
4386     } catch (...) {
4387       {
4388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4389       };
4390     }
4391   }
4392
4393   jresult = (void *)result;
4394   return jresult;
4395 }
4396
4397
4398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4399   void * jresult ;
4400   Dali::Vector2 *result = 0 ;
4401
4402   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4403   jresult = (void *)result;
4404   return jresult;
4405 }
4406
4407
4408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4409   void * jresult ;
4410   Dali::Vector2 *result = 0 ;
4411
4412   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4413   jresult = (void *)result;
4414   return jresult;
4415 }
4416
4417
4418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4419   void * jresult ;
4420   Dali::Vector2 *result = 0 ;
4421
4422   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4423   jresult = (void *)result;
4424   return jresult;
4425 }
4426
4427
4428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4429   void * jresult ;
4430   Dali::Vector2 *result = 0 ;
4431
4432   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4433   jresult = (void *)result;
4434   return jresult;
4435 }
4436
4437
4438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4439   void * jresult ;
4440   Dali::Vector2 *result = 0 ;
4441
4442   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4443   jresult = (void *)result;
4444   return jresult;
4445 }
4446
4447
4448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4449   void * jresult ;
4450   Dali::Vector2 *result = 0 ;
4451
4452   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4453   jresult = (void *)result;
4454   return jresult;
4455 }
4456
4457
4458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4459   void * jresult ;
4460   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4461   float *arg2 = (float *) 0 ;
4462   Dali::Vector2 *result = 0 ;
4463
4464   arg1 = (Dali::Vector2 *)jarg1;
4465   arg2 = jarg2;
4466   {
4467     try {
4468       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4469     } catch (std::out_of_range& e) {
4470       {
4471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4472       };
4473     } catch (std::exception& e) {
4474       {
4475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4476       };
4477     } catch (Dali::DaliException e) {
4478       {
4479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4480       };
4481     } catch (...) {
4482       {
4483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4484       };
4485     }
4486   }
4487
4488   jresult = (void *)result;
4489
4490
4491   return jresult;
4492 }
4493
4494
4495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4496   void * jresult ;
4497   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4498   Dali::Vector3 *arg2 = 0 ;
4499   Dali::Vector2 *result = 0 ;
4500
4501   arg1 = (Dali::Vector2 *)jarg1;
4502   arg2 = (Dali::Vector3 *)jarg2;
4503   if (!arg2) {
4504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4505     return 0;
4506   }
4507   {
4508     try {
4509       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4510     } catch (std::out_of_range& e) {
4511       {
4512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4513       };
4514     } catch (std::exception& e) {
4515       {
4516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4517       };
4518     } catch (Dali::DaliException e) {
4519       {
4520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4521       };
4522     } catch (...) {
4523       {
4524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4525       };
4526     }
4527   }
4528
4529   jresult = (void *)result;
4530   return jresult;
4531 }
4532
4533
4534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4535   void * jresult ;
4536   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4537   Dali::Vector4 *arg2 = 0 ;
4538   Dali::Vector2 *result = 0 ;
4539
4540   arg1 = (Dali::Vector2 *)jarg1;
4541   arg2 = (Dali::Vector4 *)jarg2;
4542   if (!arg2) {
4543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4544     return 0;
4545   }
4546   {
4547     try {
4548       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4549     } catch (std::out_of_range& e) {
4550       {
4551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4552       };
4553     } catch (std::exception& e) {
4554       {
4555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4556       };
4557     } catch (Dali::DaliException e) {
4558       {
4559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4560       };
4561     } catch (...) {
4562       {
4563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4564       };
4565     }
4566   }
4567
4568   jresult = (void *)result;
4569   return jresult;
4570 }
4571
4572
4573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4574   void * jresult ;
4575   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4576   Dali::Vector2 *arg2 = 0 ;
4577   Dali::Vector2 result;
4578
4579   arg1 = (Dali::Vector2 *)jarg1;
4580   arg2 = (Dali::Vector2 *)jarg2;
4581   if (!arg2) {
4582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4583     return 0;
4584   }
4585   {
4586     try {
4587       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4588     } catch (std::out_of_range& e) {
4589       {
4590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4591       };
4592     } catch (std::exception& e) {
4593       {
4594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4595       };
4596     } catch (Dali::DaliException e) {
4597       {
4598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4599       };
4600     } catch (...) {
4601       {
4602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4603       };
4604     }
4605   }
4606
4607   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4608   return jresult;
4609 }
4610
4611
4612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4613   void * jresult ;
4614   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4615   Dali::Vector2 *arg2 = 0 ;
4616   Dali::Vector2 *result = 0 ;
4617
4618   arg1 = (Dali::Vector2 *)jarg1;
4619   arg2 = (Dali::Vector2 *)jarg2;
4620   if (!arg2) {
4621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4622     return 0;
4623   }
4624   {
4625     try {
4626       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4627     } catch (std::out_of_range& e) {
4628       {
4629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4630       };
4631     } catch (std::exception& e) {
4632       {
4633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4634       };
4635     } catch (Dali::DaliException e) {
4636       {
4637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4638       };
4639     } catch (...) {
4640       {
4641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4642       };
4643     }
4644   }
4645
4646   jresult = (void *)result;
4647   return jresult;
4648 }
4649
4650
4651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4652   void * jresult ;
4653   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4654   Dali::Vector2 *arg2 = 0 ;
4655   Dali::Vector2 result;
4656
4657   arg1 = (Dali::Vector2 *)jarg1;
4658   arg2 = (Dali::Vector2 *)jarg2;
4659   if (!arg2) {
4660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4661     return 0;
4662   }
4663   {
4664     try {
4665       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4666     } catch (std::out_of_range& e) {
4667       {
4668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4669       };
4670     } catch (std::exception& e) {
4671       {
4672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4673       };
4674     } catch (Dali::DaliException e) {
4675       {
4676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4677       };
4678     } catch (...) {
4679       {
4680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4681       };
4682     }
4683   }
4684
4685   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4686   return jresult;
4687 }
4688
4689
4690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4691   void * jresult ;
4692   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4693   Dali::Vector2 *arg2 = 0 ;
4694   Dali::Vector2 *result = 0 ;
4695
4696   arg1 = (Dali::Vector2 *)jarg1;
4697   arg2 = (Dali::Vector2 *)jarg2;
4698   if (!arg2) {
4699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4700     return 0;
4701   }
4702   {
4703     try {
4704       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4705     } catch (std::out_of_range& e) {
4706       {
4707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4708       };
4709     } catch (std::exception& e) {
4710       {
4711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4712       };
4713     } catch (Dali::DaliException e) {
4714       {
4715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4716       };
4717     } catch (...) {
4718       {
4719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4720       };
4721     }
4722   }
4723
4724   jresult = (void *)result;
4725   return jresult;
4726 }
4727
4728
4729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4730   void * jresult ;
4731   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4732   Dali::Vector2 *arg2 = 0 ;
4733   Dali::Vector2 result;
4734
4735   arg1 = (Dali::Vector2 *)jarg1;
4736   arg2 = (Dali::Vector2 *)jarg2;
4737   if (!arg2) {
4738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4739     return 0;
4740   }
4741   {
4742     try {
4743       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4744     } catch (std::out_of_range& e) {
4745       {
4746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4747       };
4748     } catch (std::exception& e) {
4749       {
4750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4751       };
4752     } catch (Dali::DaliException e) {
4753       {
4754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4755       };
4756     } catch (...) {
4757       {
4758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4759       };
4760     }
4761   }
4762
4763   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4764   return jresult;
4765 }
4766
4767
4768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4769   void * jresult ;
4770   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4771   float arg2 ;
4772   Dali::Vector2 result;
4773
4774   arg1 = (Dali::Vector2 *)jarg1;
4775   arg2 = (float)jarg2;
4776   {
4777     try {
4778       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4779     } catch (std::out_of_range& e) {
4780       {
4781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4782       };
4783     } catch (std::exception& e) {
4784       {
4785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4786       };
4787     } catch (Dali::DaliException e) {
4788       {
4789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4790       };
4791     } catch (...) {
4792       {
4793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4794       };
4795     }
4796   }
4797
4798   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4799   return jresult;
4800 }
4801
4802
4803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4804   void * jresult ;
4805   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4806   Dali::Vector2 *arg2 = 0 ;
4807   Dali::Vector2 *result = 0 ;
4808
4809   arg1 = (Dali::Vector2 *)jarg1;
4810   arg2 = (Dali::Vector2 *)jarg2;
4811   if (!arg2) {
4812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4813     return 0;
4814   }
4815   {
4816     try {
4817       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4818     } catch (std::out_of_range& e) {
4819       {
4820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4821       };
4822     } catch (std::exception& e) {
4823       {
4824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4825       };
4826     } catch (Dali::DaliException e) {
4827       {
4828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4829       };
4830     } catch (...) {
4831       {
4832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4833       };
4834     }
4835   }
4836
4837   jresult = (void *)result;
4838   return jresult;
4839 }
4840
4841
4842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4843   void * jresult ;
4844   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4845   float arg2 ;
4846   Dali::Vector2 *result = 0 ;
4847
4848   arg1 = (Dali::Vector2 *)jarg1;
4849   arg2 = (float)jarg2;
4850   {
4851     try {
4852       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4853     } catch (std::out_of_range& e) {
4854       {
4855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4856       };
4857     } catch (std::exception& e) {
4858       {
4859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4860       };
4861     } catch (Dali::DaliException e) {
4862       {
4863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4864       };
4865     } catch (...) {
4866       {
4867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4868       };
4869     }
4870   }
4871
4872   jresult = (void *)result;
4873   return jresult;
4874 }
4875
4876
4877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4878   void * jresult ;
4879   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4880   Dali::Vector2 *arg2 = 0 ;
4881   Dali::Vector2 result;
4882
4883   arg1 = (Dali::Vector2 *)jarg1;
4884   arg2 = (Dali::Vector2 *)jarg2;
4885   if (!arg2) {
4886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4887     return 0;
4888   }
4889   {
4890     try {
4891       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4892     } catch (std::out_of_range& e) {
4893       {
4894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4895       };
4896     } catch (std::exception& e) {
4897       {
4898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4899       };
4900     } catch (Dali::DaliException e) {
4901       {
4902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4903       };
4904     } catch (...) {
4905       {
4906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4907       };
4908     }
4909   }
4910
4911   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4912   return jresult;
4913 }
4914
4915
4916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4917   void * jresult ;
4918   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4919   float arg2 ;
4920   Dali::Vector2 result;
4921
4922   arg1 = (Dali::Vector2 *)jarg1;
4923   arg2 = (float)jarg2;
4924   {
4925     try {
4926       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4927     } catch (std::out_of_range& e) {
4928       {
4929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4930       };
4931     } catch (std::exception& e) {
4932       {
4933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4934       };
4935     } catch (Dali::DaliException e) {
4936       {
4937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4938       };
4939     } catch (...) {
4940       {
4941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4942       };
4943     }
4944   }
4945
4946   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4947   return jresult;
4948 }
4949
4950
4951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4952   void * jresult ;
4953   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4954   Dali::Vector2 *arg2 = 0 ;
4955   Dali::Vector2 *result = 0 ;
4956
4957   arg1 = (Dali::Vector2 *)jarg1;
4958   arg2 = (Dali::Vector2 *)jarg2;
4959   if (!arg2) {
4960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4961     return 0;
4962   }
4963   {
4964     try {
4965       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4966     } catch (std::out_of_range& e) {
4967       {
4968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4969       };
4970     } catch (std::exception& e) {
4971       {
4972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4973       };
4974     } catch (Dali::DaliException e) {
4975       {
4976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4977       };
4978     } catch (...) {
4979       {
4980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4981       };
4982     }
4983   }
4984
4985   jresult = (void *)result;
4986   return jresult;
4987 }
4988
4989
4990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4991   void * jresult ;
4992   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4993   float arg2 ;
4994   Dali::Vector2 *result = 0 ;
4995
4996   arg1 = (Dali::Vector2 *)jarg1;
4997   arg2 = (float)jarg2;
4998   {
4999     try {
5000       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5001     } catch (std::out_of_range& e) {
5002       {
5003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5004       };
5005     } catch (std::exception& e) {
5006       {
5007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5008       };
5009     } catch (Dali::DaliException e) {
5010       {
5011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5012       };
5013     } catch (...) {
5014       {
5015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5016       };
5017     }
5018   }
5019
5020   jresult = (void *)result;
5021   return jresult;
5022 }
5023
5024
5025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5026   void * jresult ;
5027   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5028   Dali::Vector2 result;
5029
5030   arg1 = (Dali::Vector2 *)jarg1;
5031   {
5032     try {
5033       result = ((Dali::Vector2 const *)arg1)->operator -();
5034     } catch (std::out_of_range& e) {
5035       {
5036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5037       };
5038     } catch (std::exception& e) {
5039       {
5040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5041       };
5042     } catch (Dali::DaliException e) {
5043       {
5044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5045       };
5046     } catch (...) {
5047       {
5048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5049       };
5050     }
5051   }
5052
5053   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5054   return jresult;
5055 }
5056
5057
5058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5059   unsigned int jresult ;
5060   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5061   Dali::Vector2 *arg2 = 0 ;
5062   bool result;
5063
5064   arg1 = (Dali::Vector2 *)jarg1;
5065   arg2 = (Dali::Vector2 *)jarg2;
5066   if (!arg2) {
5067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5068     return 0;
5069   }
5070   {
5071     try {
5072       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5073     } catch (std::out_of_range& e) {
5074       {
5075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5076       };
5077     } catch (std::exception& e) {
5078       {
5079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5080       };
5081     } catch (Dali::DaliException e) {
5082       {
5083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5084       };
5085     } catch (...) {
5086       {
5087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5088       };
5089     }
5090   }
5091
5092   jresult = result;
5093   return jresult;
5094 }
5095
5096
5097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5098   unsigned int jresult ;
5099   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5100   Dali::Vector2 *arg2 = 0 ;
5101   bool result;
5102
5103   arg1 = (Dali::Vector2 *)jarg1;
5104   arg2 = (Dali::Vector2 *)jarg2;
5105   if (!arg2) {
5106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5107     return 0;
5108   }
5109   {
5110     try {
5111       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5112     } catch (std::out_of_range& e) {
5113       {
5114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5115       };
5116     } catch (std::exception& e) {
5117       {
5118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5119       };
5120     } catch (Dali::DaliException e) {
5121       {
5122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5123       };
5124     } catch (...) {
5125       {
5126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5127       };
5128     }
5129   }
5130
5131   jresult = result;
5132   return jresult;
5133 }
5134
5135
5136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5137   float jresult ;
5138   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5139   unsigned int arg2 ;
5140   float *result = 0 ;
5141
5142   arg1 = (Dali::Vector2 *)jarg1;
5143   arg2 = (unsigned int)jarg2;
5144   {
5145     try {
5146       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5147     } catch (std::out_of_range& e) {
5148       {
5149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5150       };
5151     } catch (std::exception& e) {
5152       {
5153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5154       };
5155     } catch (Dali::DaliException e) {
5156       {
5157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5158       };
5159     } catch (...) {
5160       {
5161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5162       };
5163     }
5164   }
5165
5166   jresult = *result;
5167   return jresult;
5168 }
5169
5170
5171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5172   float jresult ;
5173   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5174   float result;
5175
5176   arg1 = (Dali::Vector2 *)jarg1;
5177   {
5178     try {
5179       result = (float)((Dali::Vector2 const *)arg1)->Length();
5180     } catch (std::out_of_range& e) {
5181       {
5182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5183       };
5184     } catch (std::exception& e) {
5185       {
5186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5187       };
5188     } catch (Dali::DaliException e) {
5189       {
5190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5191       };
5192     } catch (...) {
5193       {
5194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5195       };
5196     }
5197   }
5198
5199   jresult = result;
5200   return jresult;
5201 }
5202
5203
5204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5205   float jresult ;
5206   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5207   float result;
5208
5209   arg1 = (Dali::Vector2 *)jarg1;
5210   {
5211     try {
5212       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5213     } catch (std::out_of_range& e) {
5214       {
5215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5216       };
5217     } catch (std::exception& e) {
5218       {
5219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5220       };
5221     } catch (Dali::DaliException e) {
5222       {
5223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5224       };
5225     } catch (...) {
5226       {
5227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5228       };
5229     }
5230   }
5231
5232   jresult = result;
5233   return jresult;
5234 }
5235
5236
5237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5238   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5239
5240   arg1 = (Dali::Vector2 *)jarg1;
5241   {
5242     try {
5243       (arg1)->Normalize();
5244     } catch (std::out_of_range& e) {
5245       {
5246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5247       };
5248     } catch (std::exception& e) {
5249       {
5250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5251       };
5252     } catch (Dali::DaliException e) {
5253       {
5254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5255       };
5256     } catch (...) {
5257       {
5258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5259       };
5260     }
5261   }
5262
5263 }
5264
5265
5266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5267   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5268   Dali::Vector2 *arg2 = 0 ;
5269   Dali::Vector2 *arg3 = 0 ;
5270
5271   arg1 = (Dali::Vector2 *)jarg1;
5272   arg2 = (Dali::Vector2 *)jarg2;
5273   if (!arg2) {
5274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5275     return ;
5276   }
5277   arg3 = (Dali::Vector2 *)jarg3;
5278   if (!arg3) {
5279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5280     return ;
5281   }
5282   {
5283     try {
5284       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5285     } catch (std::out_of_range& e) {
5286       {
5287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5288       };
5289     } catch (std::exception& e) {
5290       {
5291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5292       };
5293     } catch (Dali::DaliException e) {
5294       {
5295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5296       };
5297     } catch (...) {
5298       {
5299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5300       };
5301     }
5302   }
5303
5304 }
5305
5306
5307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5308   void * jresult ;
5309   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5310   float *result = 0 ;
5311
5312   arg1 = (Dali::Vector2 *)jarg1;
5313   {
5314     try {
5315       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5316     } catch (std::out_of_range& e) {
5317       {
5318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5319       };
5320     } catch (std::exception& e) {
5321       {
5322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5323       };
5324     } catch (Dali::DaliException e) {
5325       {
5326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5327       };
5328     } catch (...) {
5329       {
5330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5331       };
5332     }
5333   }
5334
5335   jresult = (void *)result;
5336   return jresult;
5337 }
5338
5339
5340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5341   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5342   float arg2 ;
5343
5344   arg1 = (Dali::Vector2 *)jarg1;
5345   arg2 = (float)jarg2;
5346   if (arg1) (arg1)->x = arg2;
5347 }
5348
5349
5350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5351   float jresult ;
5352   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5353   float result;
5354
5355   arg1 = (Dali::Vector2 *)jarg1;
5356   result = (float) ((arg1)->x);
5357   jresult = result;
5358   return jresult;
5359 }
5360
5361
5362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5363   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5364   float arg2 ;
5365
5366   arg1 = (Dali::Vector2 *)jarg1;
5367   arg2 = (float)jarg2;
5368   if (arg1) (arg1)->width = arg2;
5369 }
5370
5371
5372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5373   float jresult ;
5374   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5375   float result;
5376
5377   arg1 = (Dali::Vector2 *)jarg1;
5378   result = (float) ((arg1)->width);
5379   jresult = result;
5380   return jresult;
5381 }
5382
5383
5384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5385   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5386   float arg2 ;
5387
5388   arg1 = (Dali::Vector2 *)jarg1;
5389   arg2 = (float)jarg2;
5390   if (arg1) (arg1)->y = arg2;
5391 }
5392
5393
5394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5395   float jresult ;
5396   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5397   float result;
5398
5399   arg1 = (Dali::Vector2 *)jarg1;
5400   result = (float) ((arg1)->y);
5401   jresult = result;
5402   return jresult;
5403 }
5404
5405
5406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5407   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5408   float arg2 ;
5409
5410   arg1 = (Dali::Vector2 *)jarg1;
5411   arg2 = (float)jarg2;
5412   if (arg1) (arg1)->height = arg2;
5413 }
5414
5415
5416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5417   float jresult ;
5418   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5419   float result;
5420
5421   arg1 = (Dali::Vector2 *)jarg1;
5422   result = (float) ((arg1)->height);
5423   jresult = result;
5424   return jresult;
5425 }
5426
5427
5428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5429   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5430
5431   arg1 = (Dali::Vector2 *)jarg1;
5432   {
5433     try {
5434       delete arg1;
5435     } catch (std::out_of_range& e) {
5436       {
5437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5438       };
5439     } catch (std::exception& e) {
5440       {
5441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5442       };
5443     } catch (Dali::DaliException e) {
5444       {
5445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5446       };
5447     } catch (...) {
5448       {
5449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5450       };
5451     }
5452   }
5453
5454 }
5455
5456
5457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5458   void * jresult ;
5459   Dali::Vector2 *arg1 = 0 ;
5460   Dali::Vector2 *arg2 = 0 ;
5461   Dali::Vector2 result;
5462
5463   arg1 = (Dali::Vector2 *)jarg1;
5464   if (!arg1) {
5465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5466     return 0;
5467   }
5468   arg2 = (Dali::Vector2 *)jarg2;
5469   if (!arg2) {
5470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5471     return 0;
5472   }
5473   {
5474     try {
5475       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5476     } catch (std::out_of_range& e) {
5477       {
5478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5479       };
5480     } catch (std::exception& e) {
5481       {
5482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5483       };
5484     } catch (Dali::DaliException e) {
5485       {
5486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5487       };
5488     } catch (...) {
5489       {
5490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5491       };
5492     }
5493   }
5494
5495   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5496   return jresult;
5497 }
5498
5499
5500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5501   void * jresult ;
5502   Dali::Vector2 *arg1 = 0 ;
5503   Dali::Vector2 *arg2 = 0 ;
5504   Dali::Vector2 result;
5505
5506   arg1 = (Dali::Vector2 *)jarg1;
5507   if (!arg1) {
5508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5509     return 0;
5510   }
5511   arg2 = (Dali::Vector2 *)jarg2;
5512   if (!arg2) {
5513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5514     return 0;
5515   }
5516   {
5517     try {
5518       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5519     } catch (std::out_of_range& e) {
5520       {
5521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5522       };
5523     } catch (std::exception& e) {
5524       {
5525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5526       };
5527     } catch (Dali::DaliException e) {
5528       {
5529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5530       };
5531     } catch (...) {
5532       {
5533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5534       };
5535     }
5536   }
5537
5538   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5539   return jresult;
5540 }
5541
5542
5543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5544   void * jresult ;
5545   Dali::Vector2 *arg1 = 0 ;
5546   float *arg2 = 0 ;
5547   float *arg3 = 0 ;
5548   float temp2 ;
5549   float temp3 ;
5550   Dali::Vector2 result;
5551
5552   arg1 = (Dali::Vector2 *)jarg1;
5553   if (!arg1) {
5554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5555     return 0;
5556   }
5557   temp2 = (float)jarg2;
5558   arg2 = &temp2;
5559   temp3 = (float)jarg3;
5560   arg3 = &temp3;
5561   {
5562     try {
5563       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5564     } catch (std::out_of_range& e) {
5565       {
5566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5567       };
5568     } catch (std::exception& e) {
5569       {
5570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5571       };
5572     } catch (Dali::DaliException e) {
5573       {
5574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5575       };
5576     } catch (...) {
5577       {
5578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5579       };
5580     }
5581   }
5582
5583   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5584   return jresult;
5585 }
5586
5587
5588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5589   void * jresult ;
5590   Dali::Vector3 *result = 0 ;
5591
5592   {
5593     try {
5594       result = (Dali::Vector3 *)new Dali::Vector3();
5595     } catch (std::out_of_range& e) {
5596       {
5597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5598       };
5599     } catch (std::exception& e) {
5600       {
5601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5602       };
5603     } catch (Dali::DaliException e) {
5604       {
5605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5606       };
5607     } catch (...) {
5608       {
5609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5610       };
5611     }
5612   }
5613
5614   jresult = (void *)result;
5615   return jresult;
5616 }
5617
5618
5619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5620   void * jresult ;
5621   float arg1 ;
5622   float arg2 ;
5623   float arg3 ;
5624   Dali::Vector3 *result = 0 ;
5625
5626   arg1 = (float)jarg1;
5627   arg2 = (float)jarg2;
5628   arg3 = (float)jarg3;
5629   {
5630     try {
5631       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5632     } catch (std::out_of_range& e) {
5633       {
5634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5635       };
5636     } catch (std::exception& e) {
5637       {
5638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5639       };
5640     } catch (Dali::DaliException e) {
5641       {
5642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5643       };
5644     } catch (...) {
5645       {
5646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5647       };
5648     }
5649   }
5650
5651   jresult = (void *)result;
5652   return jresult;
5653 }
5654
5655
5656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5657   void * jresult ;
5658   float *arg1 = (float *) 0 ;
5659   Dali::Vector3 *result = 0 ;
5660
5661   arg1 = jarg1;
5662   {
5663     try {
5664       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5665     } catch (std::out_of_range& e) {
5666       {
5667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5668       };
5669     } catch (std::exception& e) {
5670       {
5671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5672       };
5673     } catch (Dali::DaliException e) {
5674       {
5675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5676       };
5677     } catch (...) {
5678       {
5679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5680       };
5681     }
5682   }
5683
5684   jresult = (void *)result;
5685
5686
5687   return jresult;
5688 }
5689
5690
5691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5692   void * jresult ;
5693   Dali::Vector2 *arg1 = 0 ;
5694   Dali::Vector3 *result = 0 ;
5695
5696   arg1 = (Dali::Vector2 *)jarg1;
5697   if (!arg1) {
5698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5699     return 0;
5700   }
5701   {
5702     try {
5703       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5704     } catch (std::out_of_range& e) {
5705       {
5706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5707       };
5708     } catch (std::exception& e) {
5709       {
5710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5711       };
5712     } catch (Dali::DaliException e) {
5713       {
5714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5715       };
5716     } catch (...) {
5717       {
5718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5719       };
5720     }
5721   }
5722
5723   jresult = (void *)result;
5724   return jresult;
5725 }
5726
5727
5728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5729   void * jresult ;
5730   Dali::Vector4 *arg1 = 0 ;
5731   Dali::Vector3 *result = 0 ;
5732
5733   arg1 = (Dali::Vector4 *)jarg1;
5734   if (!arg1) {
5735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5736     return 0;
5737   }
5738   {
5739     try {
5740       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5741     } catch (std::out_of_range& e) {
5742       {
5743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5744       };
5745     } catch (std::exception& e) {
5746       {
5747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5748       };
5749     } catch (Dali::DaliException e) {
5750       {
5751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5752       };
5753     } catch (...) {
5754       {
5755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5756       };
5757     }
5758   }
5759
5760   jresult = (void *)result;
5761   return jresult;
5762 }
5763
5764
5765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5766   void * jresult ;
5767   Dali::Vector3 *result = 0 ;
5768
5769   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5770   jresult = (void *)result;
5771   return jresult;
5772 }
5773
5774
5775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5776   void * jresult ;
5777   Dali::Vector3 *result = 0 ;
5778
5779   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5780   jresult = (void *)result;
5781   return jresult;
5782 }
5783
5784
5785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5786   void * jresult ;
5787   Dali::Vector3 *result = 0 ;
5788
5789   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5790   jresult = (void *)result;
5791   return jresult;
5792 }
5793
5794
5795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5796   void * jresult ;
5797   Dali::Vector3 *result = 0 ;
5798
5799   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5800   jresult = (void *)result;
5801   return jresult;
5802 }
5803
5804
5805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5806   void * jresult ;
5807   Dali::Vector3 *result = 0 ;
5808
5809   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5810   jresult = (void *)result;
5811   return jresult;
5812 }
5813
5814
5815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5816   void * jresult ;
5817   Dali::Vector3 *result = 0 ;
5818
5819   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5820   jresult = (void *)result;
5821   return jresult;
5822 }
5823
5824
5825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5826   void * jresult ;
5827   Dali::Vector3 *result = 0 ;
5828
5829   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5830   jresult = (void *)result;
5831   return jresult;
5832 }
5833
5834
5835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5836   void * jresult ;
5837   Dali::Vector3 *result = 0 ;
5838
5839   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5840   jresult = (void *)result;
5841   return jresult;
5842 }
5843
5844
5845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5846   void * jresult ;
5847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5848   float *arg2 = (float *) 0 ;
5849   Dali::Vector3 *result = 0 ;
5850
5851   arg1 = (Dali::Vector3 *)jarg1;
5852   arg2 = jarg2;
5853   {
5854     try {
5855       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5856     } catch (std::out_of_range& e) {
5857       {
5858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5859       };
5860     } catch (std::exception& e) {
5861       {
5862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5863       };
5864     } catch (Dali::DaliException e) {
5865       {
5866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5867       };
5868     } catch (...) {
5869       {
5870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5871       };
5872     }
5873   }
5874
5875   jresult = (void *)result;
5876
5877
5878   return jresult;
5879 }
5880
5881
5882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5883   void * jresult ;
5884   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5885   Dali::Vector2 *arg2 = 0 ;
5886   Dali::Vector3 *result = 0 ;
5887
5888   arg1 = (Dali::Vector3 *)jarg1;
5889   arg2 = (Dali::Vector2 *)jarg2;
5890   if (!arg2) {
5891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5892     return 0;
5893   }
5894   {
5895     try {
5896       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5897     } catch (std::out_of_range& e) {
5898       {
5899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5900       };
5901     } catch (std::exception& e) {
5902       {
5903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5904       };
5905     } catch (Dali::DaliException e) {
5906       {
5907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5908       };
5909     } catch (...) {
5910       {
5911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5912       };
5913     }
5914   }
5915
5916   jresult = (void *)result;
5917   return jresult;
5918 }
5919
5920
5921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5922   void * jresult ;
5923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5924   Dali::Vector4 *arg2 = 0 ;
5925   Dali::Vector3 *result = 0 ;
5926
5927   arg1 = (Dali::Vector3 *)jarg1;
5928   arg2 = (Dali::Vector4 *)jarg2;
5929   if (!arg2) {
5930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5931     return 0;
5932   }
5933   {
5934     try {
5935       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5936     } catch (std::out_of_range& e) {
5937       {
5938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5939       };
5940     } catch (std::exception& e) {
5941       {
5942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5943       };
5944     } catch (Dali::DaliException e) {
5945       {
5946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5947       };
5948     } catch (...) {
5949       {
5950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5951       };
5952     }
5953   }
5954
5955   jresult = (void *)result;
5956   return jresult;
5957 }
5958
5959
5960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5961   void * jresult ;
5962   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5963   Dali::Vector3 *arg2 = 0 ;
5964   Dali::Vector3 result;
5965
5966   arg1 = (Dali::Vector3 *)jarg1;
5967   arg2 = (Dali::Vector3 *)jarg2;
5968   if (!arg2) {
5969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5970     return 0;
5971   }
5972   {
5973     try {
5974       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5975     } catch (std::out_of_range& e) {
5976       {
5977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5978       };
5979     } catch (std::exception& e) {
5980       {
5981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5982       };
5983     } catch (Dali::DaliException e) {
5984       {
5985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5986       };
5987     } catch (...) {
5988       {
5989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5990       };
5991     }
5992   }
5993
5994   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5995   return jresult;
5996 }
5997
5998
5999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6000   void * jresult ;
6001   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6002   Dali::Vector3 *arg2 = 0 ;
6003   Dali::Vector3 *result = 0 ;
6004
6005   arg1 = (Dali::Vector3 *)jarg1;
6006   arg2 = (Dali::Vector3 *)jarg2;
6007   if (!arg2) {
6008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6009     return 0;
6010   }
6011   {
6012     try {
6013       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6014     } catch (std::out_of_range& e) {
6015       {
6016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6017       };
6018     } catch (std::exception& e) {
6019       {
6020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6021       };
6022     } catch (Dali::DaliException e) {
6023       {
6024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6025       };
6026     } catch (...) {
6027       {
6028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6029       };
6030     }
6031   }
6032
6033   jresult = (void *)result;
6034   return jresult;
6035 }
6036
6037
6038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6039   void * jresult ;
6040   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6041   Dali::Vector3 *arg2 = 0 ;
6042   Dali::Vector3 result;
6043
6044   arg1 = (Dali::Vector3 *)jarg1;
6045   arg2 = (Dali::Vector3 *)jarg2;
6046   if (!arg2) {
6047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6048     return 0;
6049   }
6050   {
6051     try {
6052       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6053     } catch (std::out_of_range& e) {
6054       {
6055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6056       };
6057     } catch (std::exception& e) {
6058       {
6059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6060       };
6061     } catch (Dali::DaliException e) {
6062       {
6063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6064       };
6065     } catch (...) {
6066       {
6067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6068       };
6069     }
6070   }
6071
6072   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6073   return jresult;
6074 }
6075
6076
6077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6078   void * jresult ;
6079   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6080   Dali::Vector3 *arg2 = 0 ;
6081   Dali::Vector3 *result = 0 ;
6082
6083   arg1 = (Dali::Vector3 *)jarg1;
6084   arg2 = (Dali::Vector3 *)jarg2;
6085   if (!arg2) {
6086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6087     return 0;
6088   }
6089   {
6090     try {
6091       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6092     } catch (std::out_of_range& e) {
6093       {
6094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6095       };
6096     } catch (std::exception& e) {
6097       {
6098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6099       };
6100     } catch (Dali::DaliException e) {
6101       {
6102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6103       };
6104     } catch (...) {
6105       {
6106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6107       };
6108     }
6109   }
6110
6111   jresult = (void *)result;
6112   return jresult;
6113 }
6114
6115
6116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6117   void * jresult ;
6118   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6119   Dali::Vector3 *arg2 = 0 ;
6120   Dali::Vector3 result;
6121
6122   arg1 = (Dali::Vector3 *)jarg1;
6123   arg2 = (Dali::Vector3 *)jarg2;
6124   if (!arg2) {
6125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6126     return 0;
6127   }
6128   {
6129     try {
6130       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6131     } catch (std::out_of_range& e) {
6132       {
6133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6134       };
6135     } catch (std::exception& e) {
6136       {
6137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6138       };
6139     } catch (Dali::DaliException e) {
6140       {
6141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6142       };
6143     } catch (...) {
6144       {
6145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6146       };
6147     }
6148   }
6149
6150   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6151   return jresult;
6152 }
6153
6154
6155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6156   void * jresult ;
6157   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6158   float arg2 ;
6159   Dali::Vector3 result;
6160
6161   arg1 = (Dali::Vector3 *)jarg1;
6162   arg2 = (float)jarg2;
6163   {
6164     try {
6165       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6166     } catch (std::out_of_range& e) {
6167       {
6168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6169       };
6170     } catch (std::exception& e) {
6171       {
6172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6173       };
6174     } catch (Dali::DaliException e) {
6175       {
6176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6177       };
6178     } catch (...) {
6179       {
6180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6181       };
6182     }
6183   }
6184
6185   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6186   return jresult;
6187 }
6188
6189
6190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6191   void * jresult ;
6192   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6193   Dali::Vector3 *arg2 = 0 ;
6194   Dali::Vector3 *result = 0 ;
6195
6196   arg1 = (Dali::Vector3 *)jarg1;
6197   arg2 = (Dali::Vector3 *)jarg2;
6198   if (!arg2) {
6199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6200     return 0;
6201   }
6202   {
6203     try {
6204       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6205     } catch (std::out_of_range& e) {
6206       {
6207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6208       };
6209     } catch (std::exception& e) {
6210       {
6211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6212       };
6213     } catch (Dali::DaliException e) {
6214       {
6215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6216       };
6217     } catch (...) {
6218       {
6219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6220       };
6221     }
6222   }
6223
6224   jresult = (void *)result;
6225   return jresult;
6226 }
6227
6228
6229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6230   void * jresult ;
6231   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6232   float arg2 ;
6233   Dali::Vector3 *result = 0 ;
6234
6235   arg1 = (Dali::Vector3 *)jarg1;
6236   arg2 = (float)jarg2;
6237   {
6238     try {
6239       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6240     } catch (std::out_of_range& e) {
6241       {
6242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6243       };
6244     } catch (std::exception& e) {
6245       {
6246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6247       };
6248     } catch (Dali::DaliException e) {
6249       {
6250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6251       };
6252     } catch (...) {
6253       {
6254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6255       };
6256     }
6257   }
6258
6259   jresult = (void *)result;
6260   return jresult;
6261 }
6262
6263
6264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6265   void * jresult ;
6266   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6267   Dali::Quaternion *arg2 = 0 ;
6268   Dali::Vector3 *result = 0 ;
6269
6270   arg1 = (Dali::Vector3 *)jarg1;
6271   arg2 = (Dali::Quaternion *)jarg2;
6272   if (!arg2) {
6273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6274     return 0;
6275   }
6276   {
6277     try {
6278       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6279     } catch (std::out_of_range& e) {
6280       {
6281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6282       };
6283     } catch (std::exception& e) {
6284       {
6285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6286       };
6287     } catch (Dali::DaliException e) {
6288       {
6289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6290       };
6291     } catch (...) {
6292       {
6293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6294       };
6295     }
6296   }
6297
6298   jresult = (void *)result;
6299   return jresult;
6300 }
6301
6302
6303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6304   void * jresult ;
6305   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6306   Dali::Vector3 *arg2 = 0 ;
6307   Dali::Vector3 result;
6308
6309   arg1 = (Dali::Vector3 *)jarg1;
6310   arg2 = (Dali::Vector3 *)jarg2;
6311   if (!arg2) {
6312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6313     return 0;
6314   }
6315   {
6316     try {
6317       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6318     } catch (std::out_of_range& e) {
6319       {
6320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6321       };
6322     } catch (std::exception& e) {
6323       {
6324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6325       };
6326     } catch (Dali::DaliException e) {
6327       {
6328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6329       };
6330     } catch (...) {
6331       {
6332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6333       };
6334     }
6335   }
6336
6337   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6338   return jresult;
6339 }
6340
6341
6342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6343   void * jresult ;
6344   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6345   float arg2 ;
6346   Dali::Vector3 result;
6347
6348   arg1 = (Dali::Vector3 *)jarg1;
6349   arg2 = (float)jarg2;
6350   {
6351     try {
6352       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6353     } catch (std::out_of_range& e) {
6354       {
6355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6356       };
6357     } catch (std::exception& e) {
6358       {
6359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6360       };
6361     } catch (Dali::DaliException e) {
6362       {
6363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6364       };
6365     } catch (...) {
6366       {
6367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6368       };
6369     }
6370   }
6371
6372   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6373   return jresult;
6374 }
6375
6376
6377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6378   void * jresult ;
6379   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6380   Dali::Vector3 *arg2 = 0 ;
6381   Dali::Vector3 *result = 0 ;
6382
6383   arg1 = (Dali::Vector3 *)jarg1;
6384   arg2 = (Dali::Vector3 *)jarg2;
6385   if (!arg2) {
6386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6387     return 0;
6388   }
6389   {
6390     try {
6391       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6392     } catch (std::out_of_range& e) {
6393       {
6394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6395       };
6396     } catch (std::exception& e) {
6397       {
6398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6399       };
6400     } catch (Dali::DaliException e) {
6401       {
6402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6403       };
6404     } catch (...) {
6405       {
6406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6407       };
6408     }
6409   }
6410
6411   jresult = (void *)result;
6412   return jresult;
6413 }
6414
6415
6416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6417   void * jresult ;
6418   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6419   float arg2 ;
6420   Dali::Vector3 *result = 0 ;
6421
6422   arg1 = (Dali::Vector3 *)jarg1;
6423   arg2 = (float)jarg2;
6424   {
6425     try {
6426       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6427     } catch (std::out_of_range& e) {
6428       {
6429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6430       };
6431     } catch (std::exception& e) {
6432       {
6433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6434       };
6435     } catch (Dali::DaliException e) {
6436       {
6437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6438       };
6439     } catch (...) {
6440       {
6441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6442       };
6443     }
6444   }
6445
6446   jresult = (void *)result;
6447   return jresult;
6448 }
6449
6450
6451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6452   void * jresult ;
6453   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6454   Dali::Vector3 result;
6455
6456   arg1 = (Dali::Vector3 *)jarg1;
6457   {
6458     try {
6459       result = ((Dali::Vector3 const *)arg1)->operator -();
6460     } catch (std::out_of_range& e) {
6461       {
6462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6463       };
6464     } catch (std::exception& e) {
6465       {
6466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6467       };
6468     } catch (Dali::DaliException e) {
6469       {
6470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6471       };
6472     } catch (...) {
6473       {
6474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6475       };
6476     }
6477   }
6478
6479   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6480   return jresult;
6481 }
6482
6483
6484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6485   unsigned int jresult ;
6486   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6487   Dali::Vector3 *arg2 = 0 ;
6488   bool result;
6489
6490   arg1 = (Dali::Vector3 *)jarg1;
6491   arg2 = (Dali::Vector3 *)jarg2;
6492   if (!arg2) {
6493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6494     return 0;
6495   }
6496   {
6497     try {
6498       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6499     } catch (std::out_of_range& e) {
6500       {
6501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6502       };
6503     } catch (std::exception& e) {
6504       {
6505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6506       };
6507     } catch (Dali::DaliException e) {
6508       {
6509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6510       };
6511     } catch (...) {
6512       {
6513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6514       };
6515     }
6516   }
6517
6518   jresult = result;
6519   return jresult;
6520 }
6521
6522
6523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6524   unsigned int jresult ;
6525   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6526   Dali::Vector3 *arg2 = 0 ;
6527   bool result;
6528
6529   arg1 = (Dali::Vector3 *)jarg1;
6530   arg2 = (Dali::Vector3 *)jarg2;
6531   if (!arg2) {
6532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6533     return 0;
6534   }
6535   {
6536     try {
6537       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6538     } catch (std::out_of_range& e) {
6539       {
6540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6541       };
6542     } catch (std::exception& e) {
6543       {
6544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6545       };
6546     } catch (Dali::DaliException e) {
6547       {
6548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6549       };
6550     } catch (...) {
6551       {
6552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6553       };
6554     }
6555   }
6556
6557   jresult = result;
6558   return jresult;
6559 }
6560
6561
6562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6563   float jresult ;
6564   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6565   unsigned int arg2 ;
6566   float *result = 0 ;
6567
6568   arg1 = (Dali::Vector3 *)jarg1;
6569   arg2 = (unsigned int)jarg2;
6570   {
6571     try {
6572       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6573     } catch (std::out_of_range& e) {
6574       {
6575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6576       };
6577     } catch (std::exception& e) {
6578       {
6579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6580       };
6581     } catch (Dali::DaliException e) {
6582       {
6583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6584       };
6585     } catch (...) {
6586       {
6587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6588       };
6589     }
6590   }
6591
6592   jresult = *result;
6593   return jresult;
6594 }
6595
6596
6597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6598   float jresult ;
6599   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6600   Dali::Vector3 *arg2 = 0 ;
6601   float result;
6602
6603   arg1 = (Dali::Vector3 *)jarg1;
6604   arg2 = (Dali::Vector3 *)jarg2;
6605   if (!arg2) {
6606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6607     return 0;
6608   }
6609   {
6610     try {
6611       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6612     } catch (std::out_of_range& e) {
6613       {
6614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6615       };
6616     } catch (std::exception& e) {
6617       {
6618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6619       };
6620     } catch (Dali::DaliException e) {
6621       {
6622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6623       };
6624     } catch (...) {
6625       {
6626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6627       };
6628     }
6629   }
6630
6631   jresult = result;
6632   return jresult;
6633 }
6634
6635
6636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6637   void * jresult ;
6638   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6639   Dali::Vector3 *arg2 = 0 ;
6640   Dali::Vector3 result;
6641
6642   arg1 = (Dali::Vector3 *)jarg1;
6643   arg2 = (Dali::Vector3 *)jarg2;
6644   if (!arg2) {
6645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6646     return 0;
6647   }
6648   {
6649     try {
6650       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6651     } catch (std::out_of_range& e) {
6652       {
6653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6654       };
6655     } catch (std::exception& e) {
6656       {
6657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6658       };
6659     } catch (Dali::DaliException e) {
6660       {
6661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6662       };
6663     } catch (...) {
6664       {
6665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6666       };
6667     }
6668   }
6669
6670   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6671   return jresult;
6672 }
6673
6674
6675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6676   float jresult ;
6677   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6678   float result;
6679
6680   arg1 = (Dali::Vector3 *)jarg1;
6681   {
6682     try {
6683       result = (float)((Dali::Vector3 const *)arg1)->Length();
6684     } catch (std::out_of_range& e) {
6685       {
6686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6687       };
6688     } catch (std::exception& e) {
6689       {
6690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6691       };
6692     } catch (Dali::DaliException e) {
6693       {
6694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6695       };
6696     } catch (...) {
6697       {
6698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6699       };
6700     }
6701   }
6702
6703   jresult = result;
6704   return jresult;
6705 }
6706
6707
6708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6709   float jresult ;
6710   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6711   float result;
6712
6713   arg1 = (Dali::Vector3 *)jarg1;
6714   {
6715     try {
6716       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6717     } catch (std::out_of_range& e) {
6718       {
6719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6720       };
6721     } catch (std::exception& e) {
6722       {
6723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6724       };
6725     } catch (Dali::DaliException e) {
6726       {
6727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6728       };
6729     } catch (...) {
6730       {
6731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6732       };
6733     }
6734   }
6735
6736   jresult = result;
6737   return jresult;
6738 }
6739
6740
6741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6742   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6743
6744   arg1 = (Dali::Vector3 *)jarg1;
6745   {
6746     try {
6747       (arg1)->Normalize();
6748     } catch (std::out_of_range& e) {
6749       {
6750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6751       };
6752     } catch (std::exception& e) {
6753       {
6754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6755       };
6756     } catch (Dali::DaliException e) {
6757       {
6758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6759       };
6760     } catch (...) {
6761       {
6762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6763       };
6764     }
6765   }
6766
6767 }
6768
6769
6770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6771   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6772   Dali::Vector3 *arg2 = 0 ;
6773   Dali::Vector3 *arg3 = 0 ;
6774
6775   arg1 = (Dali::Vector3 *)jarg1;
6776   arg2 = (Dali::Vector3 *)jarg2;
6777   if (!arg2) {
6778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6779     return ;
6780   }
6781   arg3 = (Dali::Vector3 *)jarg3;
6782   if (!arg3) {
6783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6784     return ;
6785   }
6786   {
6787     try {
6788       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6789     } catch (std::out_of_range& e) {
6790       {
6791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6792       };
6793     } catch (std::exception& e) {
6794       {
6795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6796       };
6797     } catch (Dali::DaliException e) {
6798       {
6799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6800       };
6801     } catch (...) {
6802       {
6803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6804       };
6805     }
6806   }
6807
6808 }
6809
6810
6811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6812   void * jresult ;
6813   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6814   float *result = 0 ;
6815
6816   arg1 = (Dali::Vector3 *)jarg1;
6817   {
6818     try {
6819       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6820     } catch (std::out_of_range& e) {
6821       {
6822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6823       };
6824     } catch (std::exception& e) {
6825       {
6826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6827       };
6828     } catch (Dali::DaliException e) {
6829       {
6830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6831       };
6832     } catch (...) {
6833       {
6834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6835       };
6836     }
6837   }
6838
6839   jresult = (void *)result;
6840   return jresult;
6841 }
6842
6843
6844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6845   void * jresult ;
6846   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6847   Dali::Vector2 *result = 0 ;
6848
6849   arg1 = (Dali::Vector3 *)jarg1;
6850   {
6851     try {
6852       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6853     } catch (std::out_of_range& e) {
6854       {
6855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6856       };
6857     } catch (std::exception& e) {
6858       {
6859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6860       };
6861     } catch (Dali::DaliException e) {
6862       {
6863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6864       };
6865     } catch (...) {
6866       {
6867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6868       };
6869     }
6870   }
6871
6872   jresult = (void *)result;
6873   return jresult;
6874 }
6875
6876
6877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6878   void * jresult ;
6879   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6880   Dali::Vector2 *result = 0 ;
6881
6882   arg1 = (Dali::Vector3 *)jarg1;
6883   {
6884     try {
6885       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6886     } catch (std::out_of_range& e) {
6887       {
6888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6889       };
6890     } catch (std::exception& e) {
6891       {
6892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6893       };
6894     } catch (Dali::DaliException e) {
6895       {
6896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6897       };
6898     } catch (...) {
6899       {
6900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6901       };
6902     }
6903   }
6904
6905   jresult = (void *)result;
6906   return jresult;
6907 }
6908
6909
6910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6911   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6912   float arg2 ;
6913
6914   arg1 = (Dali::Vector3 *)jarg1;
6915   arg2 = (float)jarg2;
6916   if (arg1) (arg1)->x = arg2;
6917 }
6918
6919
6920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6921   float jresult ;
6922   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6923   float result;
6924
6925   arg1 = (Dali::Vector3 *)jarg1;
6926   result = (float) ((arg1)->x);
6927   jresult = result;
6928   return jresult;
6929 }
6930
6931
6932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6933   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6934   float arg2 ;
6935
6936   arg1 = (Dali::Vector3 *)jarg1;
6937   arg2 = (float)jarg2;
6938   if (arg1) (arg1)->width = arg2;
6939 }
6940
6941
6942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6943   float jresult ;
6944   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6945   float result;
6946
6947   arg1 = (Dali::Vector3 *)jarg1;
6948   result = (float) ((arg1)->width);
6949   jresult = result;
6950   return jresult;
6951 }
6952
6953
6954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6955   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6956   float arg2 ;
6957
6958   arg1 = (Dali::Vector3 *)jarg1;
6959   arg2 = (float)jarg2;
6960   if (arg1) (arg1)->r = arg2;
6961 }
6962
6963
6964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6965   float jresult ;
6966   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6967   float result;
6968
6969   arg1 = (Dali::Vector3 *)jarg1;
6970   result = (float) ((arg1)->r);
6971   jresult = result;
6972   return jresult;
6973 }
6974
6975
6976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6977   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6978   float arg2 ;
6979
6980   arg1 = (Dali::Vector3 *)jarg1;
6981   arg2 = (float)jarg2;
6982   if (arg1) (arg1)->y = arg2;
6983 }
6984
6985
6986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6987   float jresult ;
6988   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6989   float result;
6990
6991   arg1 = (Dali::Vector3 *)jarg1;
6992   result = (float) ((arg1)->y);
6993   jresult = result;
6994   return jresult;
6995 }
6996
6997
6998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6999   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7000   float arg2 ;
7001
7002   arg1 = (Dali::Vector3 *)jarg1;
7003   arg2 = (float)jarg2;
7004   if (arg1) (arg1)->height = arg2;
7005 }
7006
7007
7008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7009   float jresult ;
7010   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7011   float result;
7012
7013   arg1 = (Dali::Vector3 *)jarg1;
7014   result = (float) ((arg1)->height);
7015   jresult = result;
7016   return jresult;
7017 }
7018
7019
7020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7021   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7022   float arg2 ;
7023
7024   arg1 = (Dali::Vector3 *)jarg1;
7025   arg2 = (float)jarg2;
7026   if (arg1) (arg1)->g = arg2;
7027 }
7028
7029
7030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7031   float jresult ;
7032   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7033   float result;
7034
7035   arg1 = (Dali::Vector3 *)jarg1;
7036   result = (float) ((arg1)->g);
7037   jresult = result;
7038   return jresult;
7039 }
7040
7041
7042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7043   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7044   float arg2 ;
7045
7046   arg1 = (Dali::Vector3 *)jarg1;
7047   arg2 = (float)jarg2;
7048   if (arg1) (arg1)->z = arg2;
7049 }
7050
7051
7052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7053   float jresult ;
7054   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7055   float result;
7056
7057   arg1 = (Dali::Vector3 *)jarg1;
7058   result = (float) ((arg1)->z);
7059   jresult = result;
7060   return jresult;
7061 }
7062
7063
7064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7065   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7066   float arg2 ;
7067
7068   arg1 = (Dali::Vector3 *)jarg1;
7069   arg2 = (float)jarg2;
7070   if (arg1) (arg1)->depth = arg2;
7071 }
7072
7073
7074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7075   float jresult ;
7076   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7077   float result;
7078
7079   arg1 = (Dali::Vector3 *)jarg1;
7080   result = (float) ((arg1)->depth);
7081   jresult = result;
7082   return jresult;
7083 }
7084
7085
7086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7087   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7088   float arg2 ;
7089
7090   arg1 = (Dali::Vector3 *)jarg1;
7091   arg2 = (float)jarg2;
7092   if (arg1) (arg1)->b = arg2;
7093 }
7094
7095
7096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7097   float jresult ;
7098   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7099   float result;
7100
7101   arg1 = (Dali::Vector3 *)jarg1;
7102   result = (float) ((arg1)->b);
7103   jresult = result;
7104   return jresult;
7105 }
7106
7107
7108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7109   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7110
7111   arg1 = (Dali::Vector3 *)jarg1;
7112   {
7113     try {
7114       delete arg1;
7115     } catch (std::out_of_range& e) {
7116       {
7117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7118       };
7119     } catch (std::exception& e) {
7120       {
7121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7122       };
7123     } catch (Dali::DaliException e) {
7124       {
7125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7126       };
7127     } catch (...) {
7128       {
7129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7130       };
7131     }
7132   }
7133
7134 }
7135
7136
7137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7138   void * jresult ;
7139   Dali::Vector3 *arg1 = 0 ;
7140   Dali::Vector3 *arg2 = 0 ;
7141   Dali::Vector3 result;
7142
7143   arg1 = (Dali::Vector3 *)jarg1;
7144   if (!arg1) {
7145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7146     return 0;
7147   }
7148   arg2 = (Dali::Vector3 *)jarg2;
7149   if (!arg2) {
7150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7151     return 0;
7152   }
7153   {
7154     try {
7155       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7156     } catch (std::out_of_range& e) {
7157       {
7158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7159       };
7160     } catch (std::exception& e) {
7161       {
7162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7163       };
7164     } catch (Dali::DaliException e) {
7165       {
7166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7167       };
7168     } catch (...) {
7169       {
7170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7171       };
7172     }
7173   }
7174
7175   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7176   return jresult;
7177 }
7178
7179
7180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7181   void * jresult ;
7182   Dali::Vector3 *arg1 = 0 ;
7183   Dali::Vector3 *arg2 = 0 ;
7184   Dali::Vector3 result;
7185
7186   arg1 = (Dali::Vector3 *)jarg1;
7187   if (!arg1) {
7188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7189     return 0;
7190   }
7191   arg2 = (Dali::Vector3 *)jarg2;
7192   if (!arg2) {
7193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7194     return 0;
7195   }
7196   {
7197     try {
7198       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7199     } catch (std::out_of_range& e) {
7200       {
7201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7202       };
7203     } catch (std::exception& e) {
7204       {
7205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7206       };
7207     } catch (Dali::DaliException e) {
7208       {
7209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7210       };
7211     } catch (...) {
7212       {
7213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7214       };
7215     }
7216   }
7217
7218   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7219   return jresult;
7220 }
7221
7222
7223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7224   void * jresult ;
7225   Dali::Vector3 *arg1 = 0 ;
7226   float *arg2 = 0 ;
7227   float *arg3 = 0 ;
7228   float temp2 ;
7229   float temp3 ;
7230   Dali::Vector3 result;
7231
7232   arg1 = (Dali::Vector3 *)jarg1;
7233   if (!arg1) {
7234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7235     return 0;
7236   }
7237   temp2 = (float)jarg2;
7238   arg2 = &temp2;
7239   temp3 = (float)jarg3;
7240   arg3 = &temp3;
7241   {
7242     try {
7243       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7244     } catch (std::out_of_range& e) {
7245       {
7246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7247       };
7248     } catch (std::exception& e) {
7249       {
7250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7251       };
7252     } catch (Dali::DaliException e) {
7253       {
7254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7255       };
7256     } catch (...) {
7257       {
7258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7259       };
7260     }
7261   }
7262
7263   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7264   return jresult;
7265 }
7266
7267
7268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7269   void * jresult ;
7270   Dali::Vector4 *result = 0 ;
7271
7272   {
7273     try {
7274       result = (Dali::Vector4 *)new Dali::Vector4();
7275     } catch (std::out_of_range& e) {
7276       {
7277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7278       };
7279     } catch (std::exception& e) {
7280       {
7281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7282       };
7283     } catch (Dali::DaliException e) {
7284       {
7285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7286       };
7287     } catch (...) {
7288       {
7289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7290       };
7291     }
7292   }
7293
7294   jresult = (void *)result;
7295   return jresult;
7296 }
7297
7298
7299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7300   void * jresult ;
7301   float arg1 ;
7302   float arg2 ;
7303   float arg3 ;
7304   float arg4 ;
7305   Dali::Vector4 *result = 0 ;
7306
7307   arg1 = (float)jarg1;
7308   arg2 = (float)jarg2;
7309   arg3 = (float)jarg3;
7310   arg4 = (float)jarg4;
7311   {
7312     try {
7313       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7314     } catch (std::out_of_range& e) {
7315       {
7316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7317       };
7318     } catch (std::exception& e) {
7319       {
7320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7321       };
7322     } catch (Dali::DaliException e) {
7323       {
7324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7325       };
7326     } catch (...) {
7327       {
7328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7329       };
7330     }
7331   }
7332
7333   jresult = (void *)result;
7334   return jresult;
7335 }
7336
7337
7338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7339   void * jresult ;
7340   float *arg1 = (float *) 0 ;
7341   Dali::Vector4 *result = 0 ;
7342
7343   arg1 = jarg1;
7344   {
7345     try {
7346       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7347     } catch (std::out_of_range& e) {
7348       {
7349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7350       };
7351     } catch (std::exception& e) {
7352       {
7353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7354       };
7355     } catch (Dali::DaliException e) {
7356       {
7357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7358       };
7359     } catch (...) {
7360       {
7361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7362       };
7363     }
7364   }
7365
7366   jresult = (void *)result;
7367
7368
7369   return jresult;
7370 }
7371
7372
7373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7374   void * jresult ;
7375   Dali::Vector2 *arg1 = 0 ;
7376   Dali::Vector4 *result = 0 ;
7377
7378   arg1 = (Dali::Vector2 *)jarg1;
7379   if (!arg1) {
7380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7381     return 0;
7382   }
7383   {
7384     try {
7385       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7386     } catch (std::out_of_range& e) {
7387       {
7388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7389       };
7390     } catch (std::exception& e) {
7391       {
7392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7393       };
7394     } catch (Dali::DaliException e) {
7395       {
7396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7397       };
7398     } catch (...) {
7399       {
7400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7401       };
7402     }
7403   }
7404
7405   jresult = (void *)result;
7406   return jresult;
7407 }
7408
7409
7410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7411   void * jresult ;
7412   Dali::Vector3 *arg1 = 0 ;
7413   Dali::Vector4 *result = 0 ;
7414
7415   arg1 = (Dali::Vector3 *)jarg1;
7416   if (!arg1) {
7417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7418     return 0;
7419   }
7420   {
7421     try {
7422       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7423     } catch (std::out_of_range& e) {
7424       {
7425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7426       };
7427     } catch (std::exception& e) {
7428       {
7429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7430       };
7431     } catch (Dali::DaliException e) {
7432       {
7433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7434       };
7435     } catch (...) {
7436       {
7437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7438       };
7439     }
7440   }
7441
7442   jresult = (void *)result;
7443   return jresult;
7444 }
7445
7446
7447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7448   void * jresult ;
7449   Dali::Vector4 *result = 0 ;
7450
7451   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7452   jresult = (void *)result;
7453   return jresult;
7454 }
7455
7456
7457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7458   void * jresult ;
7459   Dali::Vector4 *result = 0 ;
7460
7461   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7462   jresult = (void *)result;
7463   return jresult;
7464 }
7465
7466
7467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7468   void * jresult ;
7469   Dali::Vector4 *result = 0 ;
7470
7471   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7472   jresult = (void *)result;
7473   return jresult;
7474 }
7475
7476
7477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7478   void * jresult ;
7479   Dali::Vector4 *result = 0 ;
7480
7481   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7482   jresult = (void *)result;
7483   return jresult;
7484 }
7485
7486
7487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7488   void * jresult ;
7489   Dali::Vector4 *result = 0 ;
7490
7491   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7492   jresult = (void *)result;
7493   return jresult;
7494 }
7495
7496
7497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7498   void * jresult ;
7499   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7500   float *arg2 = (float *) 0 ;
7501   Dali::Vector4 *result = 0 ;
7502
7503   arg1 = (Dali::Vector4 *)jarg1;
7504   arg2 = jarg2;
7505   {
7506     try {
7507       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7508     } catch (std::out_of_range& e) {
7509       {
7510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7511       };
7512     } catch (std::exception& e) {
7513       {
7514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7515       };
7516     } catch (Dali::DaliException e) {
7517       {
7518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7519       };
7520     } catch (...) {
7521       {
7522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7523       };
7524     }
7525   }
7526
7527   jresult = (void *)result;
7528
7529
7530   return jresult;
7531 }
7532
7533
7534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7535   void * jresult ;
7536   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7537   Dali::Vector2 *arg2 = 0 ;
7538   Dali::Vector4 *result = 0 ;
7539
7540   arg1 = (Dali::Vector4 *)jarg1;
7541   arg2 = (Dali::Vector2 *)jarg2;
7542   if (!arg2) {
7543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7544     return 0;
7545   }
7546   {
7547     try {
7548       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7549     } catch (std::out_of_range& e) {
7550       {
7551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7552       };
7553     } catch (std::exception& e) {
7554       {
7555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7556       };
7557     } catch (Dali::DaliException e) {
7558       {
7559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7560       };
7561     } catch (...) {
7562       {
7563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7564       };
7565     }
7566   }
7567
7568   jresult = (void *)result;
7569   return jresult;
7570 }
7571
7572
7573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7574   void * jresult ;
7575   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7576   Dali::Vector3 *arg2 = 0 ;
7577   Dali::Vector4 *result = 0 ;
7578
7579   arg1 = (Dali::Vector4 *)jarg1;
7580   arg2 = (Dali::Vector3 *)jarg2;
7581   if (!arg2) {
7582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7583     return 0;
7584   }
7585   {
7586     try {
7587       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7588     } catch (std::out_of_range& e) {
7589       {
7590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7591       };
7592     } catch (std::exception& e) {
7593       {
7594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7595       };
7596     } catch (Dali::DaliException e) {
7597       {
7598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7599       };
7600     } catch (...) {
7601       {
7602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7603       };
7604     }
7605   }
7606
7607   jresult = (void *)result;
7608   return jresult;
7609 }
7610
7611
7612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7613   void * jresult ;
7614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7615   Dali::Vector4 *arg2 = 0 ;
7616   Dali::Vector4 result;
7617
7618   arg1 = (Dali::Vector4 *)jarg1;
7619   arg2 = (Dali::Vector4 *)jarg2;
7620   if (!arg2) {
7621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7622     return 0;
7623   }
7624   {
7625     try {
7626       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7627     } catch (std::out_of_range& e) {
7628       {
7629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7630       };
7631     } catch (std::exception& e) {
7632       {
7633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7634       };
7635     } catch (Dali::DaliException e) {
7636       {
7637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7638       };
7639     } catch (...) {
7640       {
7641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7642       };
7643     }
7644   }
7645
7646   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7647   return jresult;
7648 }
7649
7650
7651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7652   void * jresult ;
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   Dali::Vector4 *arg2 = 0 ;
7655   Dali::Vector4 *result = 0 ;
7656
7657   arg1 = (Dali::Vector4 *)jarg1;
7658   arg2 = (Dali::Vector4 *)jarg2;
7659   if (!arg2) {
7660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7661     return 0;
7662   }
7663   {
7664     try {
7665       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7666     } catch (std::out_of_range& e) {
7667       {
7668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7669       };
7670     } catch (std::exception& e) {
7671       {
7672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7673       };
7674     } catch (Dali::DaliException e) {
7675       {
7676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7677       };
7678     } catch (...) {
7679       {
7680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7681       };
7682     }
7683   }
7684
7685   jresult = (void *)result;
7686   return jresult;
7687 }
7688
7689
7690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7691   void * jresult ;
7692   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7693   Dali::Vector4 *arg2 = 0 ;
7694   Dali::Vector4 result;
7695
7696   arg1 = (Dali::Vector4 *)jarg1;
7697   arg2 = (Dali::Vector4 *)jarg2;
7698   if (!arg2) {
7699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7700     return 0;
7701   }
7702   {
7703     try {
7704       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7705     } catch (std::out_of_range& e) {
7706       {
7707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7708       };
7709     } catch (std::exception& e) {
7710       {
7711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7712       };
7713     } catch (Dali::DaliException e) {
7714       {
7715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7716       };
7717     } catch (...) {
7718       {
7719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7720       };
7721     }
7722   }
7723
7724   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7725   return jresult;
7726 }
7727
7728
7729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7730   void * jresult ;
7731   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7732   Dali::Vector4 *arg2 = 0 ;
7733   Dali::Vector4 *result = 0 ;
7734
7735   arg1 = (Dali::Vector4 *)jarg1;
7736   arg2 = (Dali::Vector4 *)jarg2;
7737   if (!arg2) {
7738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7739     return 0;
7740   }
7741   {
7742     try {
7743       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7744     } catch (std::out_of_range& e) {
7745       {
7746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7747       };
7748     } catch (std::exception& e) {
7749       {
7750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7751       };
7752     } catch (Dali::DaliException e) {
7753       {
7754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7755       };
7756     } catch (...) {
7757       {
7758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7759       };
7760     }
7761   }
7762
7763   jresult = (void *)result;
7764   return jresult;
7765 }
7766
7767
7768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7769   void * jresult ;
7770   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7771   Dali::Vector4 *arg2 = 0 ;
7772   Dali::Vector4 result;
7773
7774   arg1 = (Dali::Vector4 *)jarg1;
7775   arg2 = (Dali::Vector4 *)jarg2;
7776   if (!arg2) {
7777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7778     return 0;
7779   }
7780   {
7781     try {
7782       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7783     } catch (std::out_of_range& e) {
7784       {
7785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7786       };
7787     } catch (std::exception& e) {
7788       {
7789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7790       };
7791     } catch (Dali::DaliException e) {
7792       {
7793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7794       };
7795     } catch (...) {
7796       {
7797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7798       };
7799     }
7800   }
7801
7802   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7803   return jresult;
7804 }
7805
7806
7807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7808   void * jresult ;
7809   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7810   float arg2 ;
7811   Dali::Vector4 result;
7812
7813   arg1 = (Dali::Vector4 *)jarg1;
7814   arg2 = (float)jarg2;
7815   {
7816     try {
7817       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7818     } catch (std::out_of_range& e) {
7819       {
7820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7821       };
7822     } catch (std::exception& e) {
7823       {
7824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7825       };
7826     } catch (Dali::DaliException e) {
7827       {
7828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7829       };
7830     } catch (...) {
7831       {
7832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7833       };
7834     }
7835   }
7836
7837   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7838   return jresult;
7839 }
7840
7841
7842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7843   void * jresult ;
7844   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7845   Dali::Vector4 *arg2 = 0 ;
7846   Dali::Vector4 *result = 0 ;
7847
7848   arg1 = (Dali::Vector4 *)jarg1;
7849   arg2 = (Dali::Vector4 *)jarg2;
7850   if (!arg2) {
7851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7852     return 0;
7853   }
7854   {
7855     try {
7856       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7857     } catch (std::out_of_range& e) {
7858       {
7859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7860       };
7861     } catch (std::exception& e) {
7862       {
7863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7864       };
7865     } catch (Dali::DaliException e) {
7866       {
7867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7868       };
7869     } catch (...) {
7870       {
7871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7872       };
7873     }
7874   }
7875
7876   jresult = (void *)result;
7877   return jresult;
7878 }
7879
7880
7881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7882   void * jresult ;
7883   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7884   float arg2 ;
7885   Dali::Vector4 *result = 0 ;
7886
7887   arg1 = (Dali::Vector4 *)jarg1;
7888   arg2 = (float)jarg2;
7889   {
7890     try {
7891       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7892     } catch (std::out_of_range& e) {
7893       {
7894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7895       };
7896     } catch (std::exception& e) {
7897       {
7898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7899       };
7900     } catch (Dali::DaliException e) {
7901       {
7902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7903       };
7904     } catch (...) {
7905       {
7906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7907       };
7908     }
7909   }
7910
7911   jresult = (void *)result;
7912   return jresult;
7913 }
7914
7915
7916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7917   void * jresult ;
7918   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7919   Dali::Vector4 *arg2 = 0 ;
7920   Dali::Vector4 result;
7921
7922   arg1 = (Dali::Vector4 *)jarg1;
7923   arg2 = (Dali::Vector4 *)jarg2;
7924   if (!arg2) {
7925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7926     return 0;
7927   }
7928   {
7929     try {
7930       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7931     } catch (std::out_of_range& e) {
7932       {
7933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7934       };
7935     } catch (std::exception& e) {
7936       {
7937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7938       };
7939     } catch (Dali::DaliException e) {
7940       {
7941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7942       };
7943     } catch (...) {
7944       {
7945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7946       };
7947     }
7948   }
7949
7950   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7951   return jresult;
7952 }
7953
7954
7955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7956   void * jresult ;
7957   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7958   float arg2 ;
7959   Dali::Vector4 result;
7960
7961   arg1 = (Dali::Vector4 *)jarg1;
7962   arg2 = (float)jarg2;
7963   {
7964     try {
7965       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7966     } catch (std::out_of_range& e) {
7967       {
7968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7969       };
7970     } catch (std::exception& e) {
7971       {
7972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7973       };
7974     } catch (Dali::DaliException e) {
7975       {
7976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7977       };
7978     } catch (...) {
7979       {
7980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7981       };
7982     }
7983   }
7984
7985   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7986   return jresult;
7987 }
7988
7989
7990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7991   void * jresult ;
7992   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7993   Dali::Vector4 *arg2 = 0 ;
7994   Dali::Vector4 *result = 0 ;
7995
7996   arg1 = (Dali::Vector4 *)jarg1;
7997   arg2 = (Dali::Vector4 *)jarg2;
7998   if (!arg2) {
7999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8000     return 0;
8001   }
8002   {
8003     try {
8004       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8005     } catch (std::out_of_range& e) {
8006       {
8007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8008       };
8009     } catch (std::exception& e) {
8010       {
8011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8012       };
8013     } catch (Dali::DaliException e) {
8014       {
8015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8016       };
8017     } catch (...) {
8018       {
8019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8020       };
8021     }
8022   }
8023
8024   jresult = (void *)result;
8025   return jresult;
8026 }
8027
8028
8029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8030   void * jresult ;
8031   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8032   float arg2 ;
8033   Dali::Vector4 *result = 0 ;
8034
8035   arg1 = (Dali::Vector4 *)jarg1;
8036   arg2 = (float)jarg2;
8037   {
8038     try {
8039       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8040     } catch (std::out_of_range& e) {
8041       {
8042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8043       };
8044     } catch (std::exception& e) {
8045       {
8046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8047       };
8048     } catch (Dali::DaliException e) {
8049       {
8050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8051       };
8052     } catch (...) {
8053       {
8054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8055       };
8056     }
8057   }
8058
8059   jresult = (void *)result;
8060   return jresult;
8061 }
8062
8063
8064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8065   void * jresult ;
8066   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8067   Dali::Vector4 result;
8068
8069   arg1 = (Dali::Vector4 *)jarg1;
8070   {
8071     try {
8072       result = ((Dali::Vector4 const *)arg1)->operator -();
8073     } catch (std::out_of_range& e) {
8074       {
8075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8076       };
8077     } catch (std::exception& e) {
8078       {
8079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8080       };
8081     } catch (Dali::DaliException e) {
8082       {
8083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8084       };
8085     } catch (...) {
8086       {
8087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8088       };
8089     }
8090   }
8091
8092   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8093   return jresult;
8094 }
8095
8096
8097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8098   unsigned int jresult ;
8099   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8100   Dali::Vector4 *arg2 = 0 ;
8101   bool result;
8102
8103   arg1 = (Dali::Vector4 *)jarg1;
8104   arg2 = (Dali::Vector4 *)jarg2;
8105   if (!arg2) {
8106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8107     return 0;
8108   }
8109   {
8110     try {
8111       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8112     } catch (std::out_of_range& e) {
8113       {
8114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8115       };
8116     } catch (std::exception& e) {
8117       {
8118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8119       };
8120     } catch (Dali::DaliException e) {
8121       {
8122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8123       };
8124     } catch (...) {
8125       {
8126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8127       };
8128     }
8129   }
8130
8131   jresult = result;
8132   return jresult;
8133 }
8134
8135
8136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8137   unsigned int jresult ;
8138   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8139   Dali::Vector4 *arg2 = 0 ;
8140   bool result;
8141
8142   arg1 = (Dali::Vector4 *)jarg1;
8143   arg2 = (Dali::Vector4 *)jarg2;
8144   if (!arg2) {
8145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8146     return 0;
8147   }
8148   {
8149     try {
8150       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8151     } catch (std::out_of_range& e) {
8152       {
8153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8154       };
8155     } catch (std::exception& e) {
8156       {
8157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8158       };
8159     } catch (Dali::DaliException e) {
8160       {
8161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8162       };
8163     } catch (...) {
8164       {
8165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8166       };
8167     }
8168   }
8169
8170   jresult = result;
8171   return jresult;
8172 }
8173
8174
8175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8176   float jresult ;
8177   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8178   unsigned int arg2 ;
8179   float *result = 0 ;
8180
8181   arg1 = (Dali::Vector4 *)jarg1;
8182   arg2 = (unsigned int)jarg2;
8183   {
8184     try {
8185       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8186     } catch (std::out_of_range& e) {
8187       {
8188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8189       };
8190     } catch (std::exception& e) {
8191       {
8192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8193       };
8194     } catch (Dali::DaliException e) {
8195       {
8196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8197       };
8198     } catch (...) {
8199       {
8200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8201       };
8202     }
8203   }
8204
8205   jresult = *result;
8206   return jresult;
8207 }
8208
8209
8210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8211   float jresult ;
8212   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8213   Dali::Vector3 *arg2 = 0 ;
8214   float result;
8215
8216   arg1 = (Dali::Vector4 *)jarg1;
8217   arg2 = (Dali::Vector3 *)jarg2;
8218   if (!arg2) {
8219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8220     return 0;
8221   }
8222   {
8223     try {
8224       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8225     } catch (std::out_of_range& e) {
8226       {
8227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8228       };
8229     } catch (std::exception& e) {
8230       {
8231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8232       };
8233     } catch (Dali::DaliException e) {
8234       {
8235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8236       };
8237     } catch (...) {
8238       {
8239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8240       };
8241     }
8242   }
8243
8244   jresult = result;
8245   return jresult;
8246 }
8247
8248
8249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8250   float jresult ;
8251   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8252   Dali::Vector4 *arg2 = 0 ;
8253   float result;
8254
8255   arg1 = (Dali::Vector4 *)jarg1;
8256   arg2 = (Dali::Vector4 *)jarg2;
8257   if (!arg2) {
8258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8259     return 0;
8260   }
8261   {
8262     try {
8263       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8264     } catch (std::out_of_range& e) {
8265       {
8266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8267       };
8268     } catch (std::exception& e) {
8269       {
8270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8271       };
8272     } catch (Dali::DaliException e) {
8273       {
8274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8275       };
8276     } catch (...) {
8277       {
8278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8279       };
8280     }
8281   }
8282
8283   jresult = result;
8284   return jresult;
8285 }
8286
8287
8288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8289   float jresult ;
8290   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8291   Dali::Vector4 *arg2 = 0 ;
8292   float result;
8293
8294   arg1 = (Dali::Vector4 *)jarg1;
8295   arg2 = (Dali::Vector4 *)jarg2;
8296   if (!arg2) {
8297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8298     return 0;
8299   }
8300   {
8301     try {
8302       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8303     } catch (std::out_of_range& e) {
8304       {
8305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8306       };
8307     } catch (std::exception& e) {
8308       {
8309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8310       };
8311     } catch (Dali::DaliException e) {
8312       {
8313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8314       };
8315     } catch (...) {
8316       {
8317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8318       };
8319     }
8320   }
8321
8322   jresult = result;
8323   return jresult;
8324 }
8325
8326
8327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8328   void * jresult ;
8329   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8330   Dali::Vector4 *arg2 = 0 ;
8331   Dali::Vector4 result;
8332
8333   arg1 = (Dali::Vector4 *)jarg1;
8334   arg2 = (Dali::Vector4 *)jarg2;
8335   if (!arg2) {
8336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8337     return 0;
8338   }
8339   {
8340     try {
8341       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8342     } catch (std::out_of_range& e) {
8343       {
8344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8345       };
8346     } catch (std::exception& e) {
8347       {
8348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8349       };
8350     } catch (Dali::DaliException e) {
8351       {
8352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8353       };
8354     } catch (...) {
8355       {
8356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8357       };
8358     }
8359   }
8360
8361   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8362   return jresult;
8363 }
8364
8365
8366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8367   float jresult ;
8368   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8369   float result;
8370
8371   arg1 = (Dali::Vector4 *)jarg1;
8372   {
8373     try {
8374       result = (float)((Dali::Vector4 const *)arg1)->Length();
8375     } catch (std::out_of_range& e) {
8376       {
8377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8378       };
8379     } catch (std::exception& e) {
8380       {
8381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8382       };
8383     } catch (Dali::DaliException e) {
8384       {
8385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8386       };
8387     } catch (...) {
8388       {
8389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8390       };
8391     }
8392   }
8393
8394   jresult = result;
8395   return jresult;
8396 }
8397
8398
8399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8400   float jresult ;
8401   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8402   float result;
8403
8404   arg1 = (Dali::Vector4 *)jarg1;
8405   {
8406     try {
8407       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8408     } catch (std::out_of_range& e) {
8409       {
8410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8411       };
8412     } catch (std::exception& e) {
8413       {
8414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8415       };
8416     } catch (Dali::DaliException e) {
8417       {
8418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8419       };
8420     } catch (...) {
8421       {
8422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8423       };
8424     }
8425   }
8426
8427   jresult = result;
8428   return jresult;
8429 }
8430
8431
8432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8433   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8434
8435   arg1 = (Dali::Vector4 *)jarg1;
8436   {
8437     try {
8438       (arg1)->Normalize();
8439     } catch (std::out_of_range& e) {
8440       {
8441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8442       };
8443     } catch (std::exception& e) {
8444       {
8445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8446       };
8447     } catch (Dali::DaliException e) {
8448       {
8449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8450       };
8451     } catch (...) {
8452       {
8453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8454       };
8455     }
8456   }
8457
8458 }
8459
8460
8461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8462   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8463   Dali::Vector4 *arg2 = 0 ;
8464   Dali::Vector4 *arg3 = 0 ;
8465
8466   arg1 = (Dali::Vector4 *)jarg1;
8467   arg2 = (Dali::Vector4 *)jarg2;
8468   if (!arg2) {
8469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8470     return ;
8471   }
8472   arg3 = (Dali::Vector4 *)jarg3;
8473   if (!arg3) {
8474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8475     return ;
8476   }
8477   {
8478     try {
8479       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8480     } catch (std::out_of_range& e) {
8481       {
8482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8483       };
8484     } catch (std::exception& e) {
8485       {
8486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8487       };
8488     } catch (Dali::DaliException e) {
8489       {
8490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8491       };
8492     } catch (...) {
8493       {
8494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8495       };
8496     }
8497   }
8498
8499 }
8500
8501
8502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8503   void * jresult ;
8504   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8505   float *result = 0 ;
8506
8507   arg1 = (Dali::Vector4 *)jarg1;
8508   {
8509     try {
8510       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8511     } catch (std::out_of_range& e) {
8512       {
8513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8514       };
8515     } catch (std::exception& e) {
8516       {
8517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8518       };
8519     } catch (Dali::DaliException e) {
8520       {
8521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8522       };
8523     } catch (...) {
8524       {
8525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8526       };
8527     }
8528   }
8529
8530   jresult = (void *)result;
8531   return jresult;
8532 }
8533
8534
8535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8536   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8537   float arg2 ;
8538
8539   arg1 = (Dali::Vector4 *)jarg1;
8540   arg2 = (float)jarg2;
8541   if (arg1) (arg1)->x = arg2;
8542 }
8543
8544
8545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8546   float jresult ;
8547   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8548   float result;
8549
8550   arg1 = (Dali::Vector4 *)jarg1;
8551   result = (float) ((arg1)->x);
8552   jresult = result;
8553   return jresult;
8554 }
8555
8556
8557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8558   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8559   float arg2 ;
8560
8561   arg1 = (Dali::Vector4 *)jarg1;
8562   arg2 = (float)jarg2;
8563   if (arg1) (arg1)->r = arg2;
8564 }
8565
8566
8567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8568   float jresult ;
8569   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8570   float result;
8571
8572   arg1 = (Dali::Vector4 *)jarg1;
8573   result = (float) ((arg1)->r);
8574   jresult = result;
8575   return jresult;
8576 }
8577
8578
8579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8580   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8581   float arg2 ;
8582
8583   arg1 = (Dali::Vector4 *)jarg1;
8584   arg2 = (float)jarg2;
8585   if (arg1) (arg1)->s = arg2;
8586 }
8587
8588
8589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8590   float jresult ;
8591   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8592   float result;
8593
8594   arg1 = (Dali::Vector4 *)jarg1;
8595   result = (float) ((arg1)->s);
8596   jresult = result;
8597   return jresult;
8598 }
8599
8600
8601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8602   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8603   float arg2 ;
8604
8605   arg1 = (Dali::Vector4 *)jarg1;
8606   arg2 = (float)jarg2;
8607   if (arg1) (arg1)->y = arg2;
8608 }
8609
8610
8611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8612   float jresult ;
8613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8614   float result;
8615
8616   arg1 = (Dali::Vector4 *)jarg1;
8617   result = (float) ((arg1)->y);
8618   jresult = result;
8619   return jresult;
8620 }
8621
8622
8623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8624   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8625   float arg2 ;
8626
8627   arg1 = (Dali::Vector4 *)jarg1;
8628   arg2 = (float)jarg2;
8629   if (arg1) (arg1)->g = arg2;
8630 }
8631
8632
8633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8634   float jresult ;
8635   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8636   float result;
8637
8638   arg1 = (Dali::Vector4 *)jarg1;
8639   result = (float) ((arg1)->g);
8640   jresult = result;
8641   return jresult;
8642 }
8643
8644
8645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8646   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8647   float arg2 ;
8648
8649   arg1 = (Dali::Vector4 *)jarg1;
8650   arg2 = (float)jarg2;
8651   if (arg1) (arg1)->t = arg2;
8652 }
8653
8654
8655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8656   float jresult ;
8657   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8658   float result;
8659
8660   arg1 = (Dali::Vector4 *)jarg1;
8661   result = (float) ((arg1)->t);
8662   jresult = result;
8663   return jresult;
8664 }
8665
8666
8667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8669   float arg2 ;
8670
8671   arg1 = (Dali::Vector4 *)jarg1;
8672   arg2 = (float)jarg2;
8673   if (arg1) (arg1)->z = arg2;
8674 }
8675
8676
8677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8678   float jresult ;
8679   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8680   float result;
8681
8682   arg1 = (Dali::Vector4 *)jarg1;
8683   result = (float) ((arg1)->z);
8684   jresult = result;
8685   return jresult;
8686 }
8687
8688
8689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8691   float arg2 ;
8692
8693   arg1 = (Dali::Vector4 *)jarg1;
8694   arg2 = (float)jarg2;
8695   if (arg1) (arg1)->b = arg2;
8696 }
8697
8698
8699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8700   float jresult ;
8701   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8702   float result;
8703
8704   arg1 = (Dali::Vector4 *)jarg1;
8705   result = (float) ((arg1)->b);
8706   jresult = result;
8707   return jresult;
8708 }
8709
8710
8711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8712   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8713   float arg2 ;
8714
8715   arg1 = (Dali::Vector4 *)jarg1;
8716   arg2 = (float)jarg2;
8717   if (arg1) (arg1)->p = arg2;
8718 }
8719
8720
8721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8722   float jresult ;
8723   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8724   float result;
8725
8726   arg1 = (Dali::Vector4 *)jarg1;
8727   result = (float) ((arg1)->p);
8728   jresult = result;
8729   return jresult;
8730 }
8731
8732
8733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8734   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8735   float arg2 ;
8736
8737   arg1 = (Dali::Vector4 *)jarg1;
8738   arg2 = (float)jarg2;
8739   if (arg1) (arg1)->w = arg2;
8740 }
8741
8742
8743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8744   float jresult ;
8745   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8746   float result;
8747
8748   arg1 = (Dali::Vector4 *)jarg1;
8749   result = (float) ((arg1)->w);
8750   jresult = result;
8751   return jresult;
8752 }
8753
8754
8755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8757   float arg2 ;
8758
8759   arg1 = (Dali::Vector4 *)jarg1;
8760   arg2 = (float)jarg2;
8761   if (arg1) (arg1)->a = arg2;
8762 }
8763
8764
8765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8766   float jresult ;
8767   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8768   float result;
8769
8770   arg1 = (Dali::Vector4 *)jarg1;
8771   result = (float) ((arg1)->a);
8772   jresult = result;
8773   return jresult;
8774 }
8775
8776
8777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8778   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8779   float arg2 ;
8780
8781   arg1 = (Dali::Vector4 *)jarg1;
8782   arg2 = (float)jarg2;
8783   if (arg1) (arg1)->q = arg2;
8784 }
8785
8786
8787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8788   float jresult ;
8789   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8790   float result;
8791
8792   arg1 = (Dali::Vector4 *)jarg1;
8793   result = (float) ((arg1)->q);
8794   jresult = result;
8795   return jresult;
8796 }
8797
8798
8799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8800   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8801
8802   arg1 = (Dali::Vector4 *)jarg1;
8803   {
8804     try {
8805       delete arg1;
8806     } catch (std::out_of_range& e) {
8807       {
8808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8809       };
8810     } catch (std::exception& e) {
8811       {
8812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8813       };
8814     } catch (Dali::DaliException e) {
8815       {
8816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8817       };
8818     } catch (...) {
8819       {
8820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8821       };
8822     }
8823   }
8824
8825 }
8826
8827
8828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8829   void * jresult ;
8830   Dali::Vector4 *arg1 = 0 ;
8831   Dali::Vector4 *arg2 = 0 ;
8832   Dali::Vector4 result;
8833
8834   arg1 = (Dali::Vector4 *)jarg1;
8835   if (!arg1) {
8836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8837     return 0;
8838   }
8839   arg2 = (Dali::Vector4 *)jarg2;
8840   if (!arg2) {
8841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8842     return 0;
8843   }
8844   {
8845     try {
8846       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8847     } catch (std::out_of_range& e) {
8848       {
8849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8850       };
8851     } catch (std::exception& e) {
8852       {
8853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8854       };
8855     } catch (Dali::DaliException e) {
8856       {
8857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8858       };
8859     } catch (...) {
8860       {
8861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8862       };
8863     }
8864   }
8865
8866   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8867   return jresult;
8868 }
8869
8870
8871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8872   void * jresult ;
8873   Dali::Vector4 *arg1 = 0 ;
8874   Dali::Vector4 *arg2 = 0 ;
8875   Dali::Vector4 result;
8876
8877   arg1 = (Dali::Vector4 *)jarg1;
8878   if (!arg1) {
8879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8880     return 0;
8881   }
8882   arg2 = (Dali::Vector4 *)jarg2;
8883   if (!arg2) {
8884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8885     return 0;
8886   }
8887   {
8888     try {
8889       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8890     } catch (std::out_of_range& e) {
8891       {
8892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8893       };
8894     } catch (std::exception& e) {
8895       {
8896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8897       };
8898     } catch (Dali::DaliException e) {
8899       {
8900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8901       };
8902     } catch (...) {
8903       {
8904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8905       };
8906     }
8907   }
8908
8909   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8910   return jresult;
8911 }
8912
8913
8914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8915   void * jresult ;
8916   Dali::Vector4 *arg1 = 0 ;
8917   float *arg2 = 0 ;
8918   float *arg3 = 0 ;
8919   float temp2 ;
8920   float temp3 ;
8921   Dali::Vector4 result;
8922
8923   arg1 = (Dali::Vector4 *)jarg1;
8924   if (!arg1) {
8925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8926     return 0;
8927   }
8928   temp2 = (float)jarg2;
8929   arg2 = &temp2;
8930   temp3 = (float)jarg3;
8931   arg3 = &temp3;
8932   {
8933     try {
8934       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8935     } catch (std::out_of_range& e) {
8936       {
8937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8938       };
8939     } catch (std::exception& e) {
8940       {
8941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8942       };
8943     } catch (Dali::DaliException e) {
8944       {
8945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8946       };
8947     } catch (...) {
8948       {
8949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8950       };
8951     }
8952   }
8953
8954   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8955   return jresult;
8956 }
8957
8958
8959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8960   void * jresult ;
8961   Dali::Uint16Pair *result = 0 ;
8962
8963   {
8964     try {
8965       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8966     } catch (std::out_of_range& e) {
8967       {
8968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8969       };
8970     } catch (std::exception& e) {
8971       {
8972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8973       };
8974     } catch (Dali::DaliException e) {
8975       {
8976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8977       };
8978     } catch (...) {
8979       {
8980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8981       };
8982     }
8983   }
8984
8985   jresult = (void *)result;
8986   return jresult;
8987 }
8988
8989
8990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8991   void * jresult ;
8992   uint32_t arg1 ;
8993   uint32_t arg2 ;
8994   Dali::Uint16Pair *result = 0 ;
8995
8996   arg1 = (uint32_t)jarg1;
8997   arg2 = (uint32_t)jarg2;
8998   {
8999     try {
9000       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9001     } catch (std::out_of_range& e) {
9002       {
9003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9004       };
9005     } catch (std::exception& e) {
9006       {
9007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9008       };
9009     } catch (Dali::DaliException e) {
9010       {
9011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9012       };
9013     } catch (...) {
9014       {
9015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9016       };
9017     }
9018   }
9019
9020   jresult = (void *)result;
9021   return jresult;
9022 }
9023
9024
9025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9026   void * jresult ;
9027   Dali::Uint16Pair *arg1 = 0 ;
9028   Dali::Uint16Pair *result = 0 ;
9029
9030   arg1 = (Dali::Uint16Pair *)jarg1;
9031   if (!arg1) {
9032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9033     return 0;
9034   }
9035   {
9036     try {
9037       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9038     } catch (std::out_of_range& e) {
9039       {
9040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9041       };
9042     } catch (std::exception& e) {
9043       {
9044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9045       };
9046     } catch (Dali::DaliException e) {
9047       {
9048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9049       };
9050     } catch (...) {
9051       {
9052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9053       };
9054     }
9055   }
9056
9057   jresult = (void *)result;
9058   return jresult;
9059 }
9060
9061
9062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9063   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9064   uint16_t arg2 ;
9065
9066   arg1 = (Dali::Uint16Pair *)jarg1;
9067   arg2 = (uint16_t)jarg2;
9068   {
9069     try {
9070       (arg1)->SetWidth(arg2);
9071     } catch (std::out_of_range& e) {
9072       {
9073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9074       };
9075     } catch (std::exception& e) {
9076       {
9077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9078       };
9079     } catch (Dali::DaliException e) {
9080       {
9081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9082       };
9083     } catch (...) {
9084       {
9085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9086       };
9087     }
9088   }
9089
9090 }
9091
9092
9093 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9094   unsigned short jresult ;
9095   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9096   uint16_t result;
9097
9098   arg1 = (Dali::Uint16Pair *)jarg1;
9099   {
9100     try {
9101       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9102     } catch (std::out_of_range& e) {
9103       {
9104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9105       };
9106     } catch (std::exception& e) {
9107       {
9108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9109       };
9110     } catch (Dali::DaliException e) {
9111       {
9112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9113       };
9114     } catch (...) {
9115       {
9116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9117       };
9118     }
9119   }
9120
9121   jresult = result;
9122   return jresult;
9123 }
9124
9125
9126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9127   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9128   uint16_t arg2 ;
9129
9130   arg1 = (Dali::Uint16Pair *)jarg1;
9131   arg2 = (uint16_t)jarg2;
9132   {
9133     try {
9134       (arg1)->SetHeight(arg2);
9135     } catch (std::out_of_range& e) {
9136       {
9137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9138       };
9139     } catch (std::exception& e) {
9140       {
9141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9142       };
9143     } catch (Dali::DaliException e) {
9144       {
9145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9146       };
9147     } catch (...) {
9148       {
9149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9150       };
9151     }
9152   }
9153
9154 }
9155
9156
9157 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9158   unsigned short jresult ;
9159   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9160   uint16_t result;
9161
9162   arg1 = (Dali::Uint16Pair *)jarg1;
9163   {
9164     try {
9165       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9166     } catch (std::out_of_range& e) {
9167       {
9168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9169       };
9170     } catch (std::exception& e) {
9171       {
9172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9173       };
9174     } catch (Dali::DaliException e) {
9175       {
9176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9177       };
9178     } catch (...) {
9179       {
9180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9181       };
9182     }
9183   }
9184
9185   jresult = result;
9186   return jresult;
9187 }
9188
9189
9190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9191   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9192   uint16_t arg2 ;
9193
9194   arg1 = (Dali::Uint16Pair *)jarg1;
9195   arg2 = (uint16_t)jarg2;
9196   {
9197     try {
9198       (arg1)->SetX(arg2);
9199     } catch (std::out_of_range& e) {
9200       {
9201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9202       };
9203     } catch (std::exception& e) {
9204       {
9205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9206       };
9207     } catch (Dali::DaliException e) {
9208       {
9209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9210       };
9211     } catch (...) {
9212       {
9213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9214       };
9215     }
9216   }
9217
9218 }
9219
9220
9221 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9222   unsigned short jresult ;
9223   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9224   uint16_t result;
9225
9226   arg1 = (Dali::Uint16Pair *)jarg1;
9227   {
9228     try {
9229       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9230     } catch (std::out_of_range& e) {
9231       {
9232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9233       };
9234     } catch (std::exception& e) {
9235       {
9236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9237       };
9238     } catch (Dali::DaliException e) {
9239       {
9240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9241       };
9242     } catch (...) {
9243       {
9244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9245       };
9246     }
9247   }
9248
9249   jresult = result;
9250   return jresult;
9251 }
9252
9253
9254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9255   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9256   uint16_t arg2 ;
9257
9258   arg1 = (Dali::Uint16Pair *)jarg1;
9259   arg2 = (uint16_t)jarg2;
9260   {
9261     try {
9262       (arg1)->SetY(arg2);
9263     } catch (std::out_of_range& e) {
9264       {
9265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9266       };
9267     } catch (std::exception& e) {
9268       {
9269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9270       };
9271     } catch (Dali::DaliException e) {
9272       {
9273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9274       };
9275     } catch (...) {
9276       {
9277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9278       };
9279     }
9280   }
9281
9282 }
9283
9284
9285 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9286   unsigned short jresult ;
9287   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9288   uint16_t result;
9289
9290   arg1 = (Dali::Uint16Pair *)jarg1;
9291   {
9292     try {
9293       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9294     } catch (std::out_of_range& e) {
9295       {
9296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9297       };
9298     } catch (std::exception& e) {
9299       {
9300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9301       };
9302     } catch (Dali::DaliException e) {
9303       {
9304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9305       };
9306     } catch (...) {
9307       {
9308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9309       };
9310     }
9311   }
9312
9313   jresult = result;
9314   return jresult;
9315 }
9316
9317
9318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9319   void * jresult ;
9320   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9321   Dali::Uint16Pair *arg2 = 0 ;
9322   Dali::Uint16Pair *result = 0 ;
9323
9324   arg1 = (Dali::Uint16Pair *)jarg1;
9325   arg2 = (Dali::Uint16Pair *)jarg2;
9326   if (!arg2) {
9327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9328     return 0;
9329   }
9330   {
9331     try {
9332       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9333     } catch (std::out_of_range& e) {
9334       {
9335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9336       };
9337     } catch (std::exception& e) {
9338       {
9339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9340       };
9341     } catch (Dali::DaliException e) {
9342       {
9343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9344       };
9345     } catch (...) {
9346       {
9347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9348       };
9349     }
9350   }
9351
9352   jresult = (void *)result;
9353   return jresult;
9354 }
9355
9356
9357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9358   unsigned int jresult ;
9359   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9360   Dali::Uint16Pair *arg2 = 0 ;
9361   bool result;
9362
9363   arg1 = (Dali::Uint16Pair *)jarg1;
9364   arg2 = (Dali::Uint16Pair *)jarg2;
9365   if (!arg2) {
9366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9367     return 0;
9368   }
9369   {
9370     try {
9371       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9372     } catch (std::out_of_range& e) {
9373       {
9374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9375       };
9376     } catch (std::exception& e) {
9377       {
9378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9379       };
9380     } catch (Dali::DaliException e) {
9381       {
9382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9383       };
9384     } catch (...) {
9385       {
9386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9387       };
9388     }
9389   }
9390
9391   jresult = result;
9392   return jresult;
9393 }
9394
9395
9396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9397   unsigned int jresult ;
9398   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9399   Dali::Uint16Pair *arg2 = 0 ;
9400   bool result;
9401
9402   arg1 = (Dali::Uint16Pair *)jarg1;
9403   arg2 = (Dali::Uint16Pair *)jarg2;
9404   if (!arg2) {
9405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9406     return 0;
9407   }
9408   {
9409     try {
9410       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9411     } catch (std::out_of_range& e) {
9412       {
9413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9414       };
9415     } catch (std::exception& e) {
9416       {
9417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9418       };
9419     } catch (Dali::DaliException e) {
9420       {
9421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9422       };
9423     } catch (...) {
9424       {
9425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9426       };
9427     }
9428   }
9429
9430   jresult = result;
9431   return jresult;
9432 }
9433
9434
9435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9436   unsigned int jresult ;
9437   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9438   Dali::Uint16Pair *arg2 = 0 ;
9439   bool result;
9440
9441   arg1 = (Dali::Uint16Pair *)jarg1;
9442   arg2 = (Dali::Uint16Pair *)jarg2;
9443   if (!arg2) {
9444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9445     return 0;
9446   }
9447   {
9448     try {
9449       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9450     } catch (std::out_of_range& e) {
9451       {
9452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9453       };
9454     } catch (std::exception& e) {
9455       {
9456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9457       };
9458     } catch (Dali::DaliException e) {
9459       {
9460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9461       };
9462     } catch (...) {
9463       {
9464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9465       };
9466     }
9467   }
9468
9469   jresult = result;
9470   return jresult;
9471 }
9472
9473
9474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9475   unsigned int jresult ;
9476   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9477   Dali::Uint16Pair *arg2 = 0 ;
9478   bool result;
9479
9480   arg1 = (Dali::Uint16Pair *)jarg1;
9481   arg2 = (Dali::Uint16Pair *)jarg2;
9482   if (!arg2) {
9483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9484     return 0;
9485   }
9486   {
9487     try {
9488       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9489     } catch (std::out_of_range& e) {
9490       {
9491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9492       };
9493     } catch (std::exception& e) {
9494       {
9495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9496       };
9497     } catch (Dali::DaliException e) {
9498       {
9499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9500       };
9501     } catch (...) {
9502       {
9503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9504       };
9505     }
9506   }
9507
9508   jresult = result;
9509   return jresult;
9510 }
9511
9512
9513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9514   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9515
9516   arg1 = (Dali::Uint16Pair *)jarg1;
9517   {
9518     try {
9519       delete arg1;
9520     } catch (std::out_of_range& e) {
9521       {
9522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9523       };
9524     } catch (std::exception& e) {
9525       {
9526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9527       };
9528     } catch (Dali::DaliException e) {
9529       {
9530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9531       };
9532     } catch (...) {
9533       {
9534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9535       };
9536     }
9537   }
9538
9539 }
9540
9541
9542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9543   void * jresult ;
9544   Dali::Degree *result = 0 ;
9545
9546   {
9547     try {
9548       result = (Dali::Degree *)new Dali::Degree();
9549     } catch (std::out_of_range& e) {
9550       {
9551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9552       };
9553     } catch (std::exception& e) {
9554       {
9555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9556       };
9557     } catch (Dali::DaliException e) {
9558       {
9559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9560       };
9561     } catch (...) {
9562       {
9563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9564       };
9565     }
9566   }
9567
9568   jresult = (void *)result;
9569   return jresult;
9570 }
9571
9572
9573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9574   void * jresult ;
9575   float arg1 ;
9576   Dali::Degree *result = 0 ;
9577
9578   arg1 = (float)jarg1;
9579   {
9580     try {
9581       result = (Dali::Degree *)new Dali::Degree(arg1);
9582     } catch (std::out_of_range& e) {
9583       {
9584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9585       };
9586     } catch (std::exception& e) {
9587       {
9588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9589       };
9590     } catch (Dali::DaliException e) {
9591       {
9592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9593       };
9594     } catch (...) {
9595       {
9596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9597       };
9598     }
9599   }
9600
9601   jresult = (void *)result;
9602   return jresult;
9603 }
9604
9605
9606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9607   void * jresult ;
9608   Dali::Radian arg1 ;
9609   Dali::Radian *argp1 ;
9610   Dali::Degree *result = 0 ;
9611
9612   argp1 = (Dali::Radian *)jarg1;
9613   if (!argp1) {
9614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9615     return 0;
9616   }
9617   arg1 = *argp1;
9618   {
9619     try {
9620       result = (Dali::Degree *)new Dali::Degree(arg1);
9621     } catch (std::out_of_range& e) {
9622       {
9623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9624       };
9625     } catch (std::exception& e) {
9626       {
9627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9628       };
9629     } catch (Dali::DaliException e) {
9630       {
9631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9632       };
9633     } catch (...) {
9634       {
9635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9636       };
9637     }
9638   }
9639
9640   jresult = (void *)result;
9641   return jresult;
9642 }
9643
9644
9645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9646   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9647   float arg2 ;
9648
9649   arg1 = (Dali::Degree *)jarg1;
9650   arg2 = (float)jarg2;
9651   if (arg1) (arg1)->degree = arg2;
9652 }
9653
9654
9655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9656   float jresult ;
9657   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9658   float result;
9659
9660   arg1 = (Dali::Degree *)jarg1;
9661   result = (float) ((arg1)->degree);
9662   jresult = result;
9663   return jresult;
9664 }
9665
9666
9667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9668   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9669
9670   arg1 = (Dali::Degree *)jarg1;
9671   {
9672     try {
9673       delete arg1;
9674     } catch (std::out_of_range& e) {
9675       {
9676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9677       };
9678     } catch (std::exception& e) {
9679       {
9680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9681       };
9682     } catch (Dali::DaliException e) {
9683       {
9684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9685       };
9686     } catch (...) {
9687       {
9688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9689       };
9690     }
9691   }
9692
9693 }
9694
9695
9696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9697   void * jresult ;
9698   Dali::Radian *result = 0 ;
9699
9700   result = (Dali::Radian *)&Dali::ANGLE_360;
9701   jresult = (void *)result;
9702   return jresult;
9703 }
9704
9705
9706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9707   void * jresult ;
9708   Dali::Radian *result = 0 ;
9709
9710   result = (Dali::Radian *)&Dali::ANGLE_315;
9711   jresult = (void *)result;
9712   return jresult;
9713 }
9714
9715
9716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9717   void * jresult ;
9718   Dali::Radian *result = 0 ;
9719
9720   result = (Dali::Radian *)&Dali::ANGLE_270;
9721   jresult = (void *)result;
9722   return jresult;
9723 }
9724
9725
9726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9727   void * jresult ;
9728   Dali::Radian *result = 0 ;
9729
9730   result = (Dali::Radian *)&Dali::ANGLE_225;
9731   jresult = (void *)result;
9732   return jresult;
9733 }
9734
9735
9736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9737   void * jresult ;
9738   Dali::Radian *result = 0 ;
9739
9740   result = (Dali::Radian *)&Dali::ANGLE_180;
9741   jresult = (void *)result;
9742   return jresult;
9743 }
9744
9745
9746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9747   void * jresult ;
9748   Dali::Radian *result = 0 ;
9749
9750   result = (Dali::Radian *)&Dali::ANGLE_135;
9751   jresult = (void *)result;
9752   return jresult;
9753 }
9754
9755
9756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9757   void * jresult ;
9758   Dali::Radian *result = 0 ;
9759
9760   result = (Dali::Radian *)&Dali::ANGLE_120;
9761   jresult = (void *)result;
9762   return jresult;
9763 }
9764
9765
9766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9767   void * jresult ;
9768   Dali::Radian *result = 0 ;
9769
9770   result = (Dali::Radian *)&Dali::ANGLE_90;
9771   jresult = (void *)result;
9772   return jresult;
9773 }
9774
9775
9776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9777   void * jresult ;
9778   Dali::Radian *result = 0 ;
9779
9780   result = (Dali::Radian *)&Dali::ANGLE_60;
9781   jresult = (void *)result;
9782   return jresult;
9783 }
9784
9785
9786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9787   void * jresult ;
9788   Dali::Radian *result = 0 ;
9789
9790   result = (Dali::Radian *)&Dali::ANGLE_45;
9791   jresult = (void *)result;
9792   return jresult;
9793 }
9794
9795
9796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9797   void * jresult ;
9798   Dali::Radian *result = 0 ;
9799
9800   result = (Dali::Radian *)&Dali::ANGLE_30;
9801   jresult = (void *)result;
9802   return jresult;
9803 }
9804
9805
9806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9807   void * jresult ;
9808   Dali::Radian *result = 0 ;
9809
9810   result = (Dali::Radian *)&Dali::ANGLE_0;
9811   jresult = (void *)result;
9812   return jresult;
9813 }
9814
9815
9816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9817   unsigned int jresult ;
9818   Dali::Degree *arg1 = 0 ;
9819   Dali::Degree *arg2 = 0 ;
9820   bool result;
9821
9822   arg1 = (Dali::Degree *)jarg1;
9823   if (!arg1) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9825     return 0;
9826   }
9827   arg2 = (Dali::Degree *)jarg2;
9828   if (!arg2) {
9829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9830     return 0;
9831   }
9832   {
9833     try {
9834       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9835     } catch (std::out_of_range& e) {
9836       {
9837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9838       };
9839     } catch (std::exception& e) {
9840       {
9841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9842       };
9843     } catch (Dali::DaliException e) {
9844       {
9845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9846       };
9847     } catch (...) {
9848       {
9849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9850       };
9851     }
9852   }
9853
9854   jresult = result;
9855   return jresult;
9856 }
9857
9858
9859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9860   unsigned int jresult ;
9861   Dali::Degree *arg1 = 0 ;
9862   Dali::Degree *arg2 = 0 ;
9863   bool result;
9864
9865   arg1 = (Dali::Degree *)jarg1;
9866   if (!arg1) {
9867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9868     return 0;
9869   }
9870   arg2 = (Dali::Degree *)jarg2;
9871   if (!arg2) {
9872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9873     return 0;
9874   }
9875   {
9876     try {
9877       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9878     } catch (std::out_of_range& e) {
9879       {
9880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9881       };
9882     } catch (std::exception& e) {
9883       {
9884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9885       };
9886     } catch (Dali::DaliException e) {
9887       {
9888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9889       };
9890     } catch (...) {
9891       {
9892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9893       };
9894     }
9895   }
9896
9897   jresult = result;
9898   return jresult;
9899 }
9900
9901
9902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9903   void * jresult ;
9904   Dali::Degree arg1 ;
9905   float arg2 ;
9906   float arg3 ;
9907   Dali::Degree *argp1 ;
9908   Dali::Degree result;
9909
9910   argp1 = (Dali::Degree *)jarg1;
9911   if (!argp1) {
9912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9913     return 0;
9914   }
9915   arg1 = *argp1;
9916   arg2 = (float)jarg2;
9917   arg3 = (float)jarg3;
9918   {
9919     try {
9920       result = Dali::Clamp(arg1,arg2,arg3);
9921     } catch (std::out_of_range& e) {
9922       {
9923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9924       };
9925     } catch (std::exception& e) {
9926       {
9927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9928       };
9929     } catch (Dali::DaliException e) {
9930       {
9931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9932       };
9933     } catch (...) {
9934       {
9935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9936       };
9937     }
9938   }
9939
9940   jresult = new Dali::Degree((const Dali::Degree &)result);
9941   return jresult;
9942 }
9943
9944
9945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9946   void * jresult ;
9947   Dali::Radian *result = 0 ;
9948
9949   {
9950     try {
9951       result = (Dali::Radian *)new Dali::Radian();
9952     } catch (std::out_of_range& e) {
9953       {
9954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9955       };
9956     } catch (std::exception& e) {
9957       {
9958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9959       };
9960     } catch (Dali::DaliException e) {
9961       {
9962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9963       };
9964     } catch (...) {
9965       {
9966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9967       };
9968     }
9969   }
9970
9971   jresult = (void *)result;
9972   return jresult;
9973 }
9974
9975
9976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9977   void * jresult ;
9978   float arg1 ;
9979   Dali::Radian *result = 0 ;
9980
9981   arg1 = (float)jarg1;
9982   {
9983     try {
9984       result = (Dali::Radian *)new Dali::Radian(arg1);
9985     } catch (std::out_of_range& e) {
9986       {
9987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9988       };
9989     } catch (std::exception& e) {
9990       {
9991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9992       };
9993     } catch (Dali::DaliException e) {
9994       {
9995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9996       };
9997     } catch (...) {
9998       {
9999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10000       };
10001     }
10002   }
10003
10004   jresult = (void *)result;
10005   return jresult;
10006 }
10007
10008
10009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10010   void * jresult ;
10011   Dali::Degree arg1 ;
10012   Dali::Degree *argp1 ;
10013   Dali::Radian *result = 0 ;
10014
10015   argp1 = (Dali::Degree *)jarg1;
10016   if (!argp1) {
10017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10018     return 0;
10019   }
10020   arg1 = *argp1;
10021   {
10022     try {
10023       result = (Dali::Radian *)new Dali::Radian(arg1);
10024     } catch (std::out_of_range& e) {
10025       {
10026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10027       };
10028     } catch (std::exception& e) {
10029       {
10030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10031       };
10032     } catch (Dali::DaliException e) {
10033       {
10034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10035       };
10036     } catch (...) {
10037       {
10038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10039       };
10040     }
10041   }
10042
10043   jresult = (void *)result;
10044   return jresult;
10045 }
10046
10047
10048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10049   void * jresult ;
10050   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10051   float arg2 ;
10052   Dali::Radian *result = 0 ;
10053
10054   arg1 = (Dali::Radian *)jarg1;
10055   arg2 = (float)jarg2;
10056   {
10057     try {
10058       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10059     } catch (std::out_of_range& e) {
10060       {
10061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10062       };
10063     } catch (std::exception& e) {
10064       {
10065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10066       };
10067     } catch (Dali::DaliException e) {
10068       {
10069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10070       };
10071     } catch (...) {
10072       {
10073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10074       };
10075     }
10076   }
10077
10078   jresult = (void *)result;
10079   return jresult;
10080 }
10081
10082
10083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10084   void * jresult ;
10085   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10086   Dali::Degree arg2 ;
10087   Dali::Degree *argp2 ;
10088   Dali::Radian *result = 0 ;
10089
10090   arg1 = (Dali::Radian *)jarg1;
10091   argp2 = (Dali::Degree *)jarg2;
10092   if (!argp2) {
10093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10094     return 0;
10095   }
10096   arg2 = *argp2;
10097   {
10098     try {
10099       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10100     } catch (std::out_of_range& e) {
10101       {
10102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10103       };
10104     } catch (std::exception& e) {
10105       {
10106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10107       };
10108     } catch (Dali::DaliException e) {
10109       {
10110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10111       };
10112     } catch (...) {
10113       {
10114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10115       };
10116     }
10117   }
10118
10119   jresult = (void *)result;
10120   return jresult;
10121 }
10122
10123
10124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10125   float jresult ;
10126   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10127   float result;
10128
10129   arg1 = (Dali::Radian *)jarg1;
10130   {
10131     try {
10132       result = (float)((Dali::Radian const *)arg1)->operator float();
10133     } catch (std::out_of_range& e) {
10134       {
10135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10136       };
10137     } catch (std::exception& e) {
10138       {
10139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10140       };
10141     } catch (Dali::DaliException e) {
10142       {
10143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10144       };
10145     } catch (...) {
10146       {
10147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10148       };
10149     }
10150   }
10151
10152   jresult = result;
10153   return jresult;
10154 }
10155
10156
10157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10158   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10159   float arg2 ;
10160
10161   arg1 = (Dali::Radian *)jarg1;
10162   arg2 = (float)jarg2;
10163   if (arg1) (arg1)->radian = arg2;
10164 }
10165
10166
10167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10168   float jresult ;
10169   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10170   float result;
10171
10172   arg1 = (Dali::Radian *)jarg1;
10173   result = (float) ((arg1)->radian);
10174   jresult = result;
10175   return jresult;
10176 }
10177
10178
10179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10180   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10181
10182   arg1 = (Dali::Radian *)jarg1;
10183   {
10184     try {
10185       delete arg1;
10186     } catch (std::out_of_range& e) {
10187       {
10188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10189       };
10190     } catch (std::exception& e) {
10191       {
10192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10193       };
10194     } catch (Dali::DaliException e) {
10195       {
10196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10197       };
10198     } catch (...) {
10199       {
10200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10201       };
10202     }
10203   }
10204
10205 }
10206
10207
10208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10209   unsigned int jresult ;
10210   Dali::Radian arg1 ;
10211   Dali::Radian arg2 ;
10212   Dali::Radian *argp1 ;
10213   Dali::Radian *argp2 ;
10214   bool result;
10215
10216   argp1 = (Dali::Radian *)jarg1;
10217   if (!argp1) {
10218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10219     return 0;
10220   }
10221   arg1 = *argp1;
10222   argp2 = (Dali::Radian *)jarg2;
10223   if (!argp2) {
10224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10225     return 0;
10226   }
10227   arg2 = *argp2;
10228   {
10229     try {
10230       result = (bool)Dali::operator ==(arg1,arg2);
10231     } catch (std::out_of_range& e) {
10232       {
10233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10234       };
10235     } catch (std::exception& e) {
10236       {
10237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10238       };
10239     } catch (Dali::DaliException e) {
10240       {
10241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10242       };
10243     } catch (...) {
10244       {
10245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10246       };
10247     }
10248   }
10249
10250   jresult = result;
10251   return jresult;
10252 }
10253
10254
10255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10256   unsigned int jresult ;
10257   Dali::Radian arg1 ;
10258   Dali::Radian arg2 ;
10259   Dali::Radian *argp1 ;
10260   Dali::Radian *argp2 ;
10261   bool result;
10262
10263   argp1 = (Dali::Radian *)jarg1;
10264   if (!argp1) {
10265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10266     return 0;
10267   }
10268   arg1 = *argp1;
10269   argp2 = (Dali::Radian *)jarg2;
10270   if (!argp2) {
10271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10272     return 0;
10273   }
10274   arg2 = *argp2;
10275   {
10276     try {
10277       result = (bool)Dali::operator !=(arg1,arg2);
10278     } catch (std::out_of_range& e) {
10279       {
10280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (std::exception& e) {
10283       {
10284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10285       };
10286     } catch (Dali::DaliException e) {
10287       {
10288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10289       };
10290     } catch (...) {
10291       {
10292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10293       };
10294     }
10295   }
10296
10297   jresult = result;
10298   return jresult;
10299 }
10300
10301
10302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10303   unsigned int jresult ;
10304   Dali::Radian arg1 ;
10305   Dali::Degree arg2 ;
10306   Dali::Radian *argp1 ;
10307   Dali::Degree *argp2 ;
10308   bool result;
10309
10310   argp1 = (Dali::Radian *)jarg1;
10311   if (!argp1) {
10312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10313     return 0;
10314   }
10315   arg1 = *argp1;
10316   argp2 = (Dali::Degree *)jarg2;
10317   if (!argp2) {
10318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10319     return 0;
10320   }
10321   arg2 = *argp2;
10322   {
10323     try {
10324       result = (bool)Dali::operator ==(arg1,arg2);
10325     } catch (std::out_of_range& e) {
10326       {
10327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10328       };
10329     } catch (std::exception& e) {
10330       {
10331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10332       };
10333     } catch (Dali::DaliException e) {
10334       {
10335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10336       };
10337     } catch (...) {
10338       {
10339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10340       };
10341     }
10342   }
10343
10344   jresult = result;
10345   return jresult;
10346 }
10347
10348
10349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10350   unsigned int jresult ;
10351   Dali::Radian arg1 ;
10352   Dali::Degree arg2 ;
10353   Dali::Radian *argp1 ;
10354   Dali::Degree *argp2 ;
10355   bool result;
10356
10357   argp1 = (Dali::Radian *)jarg1;
10358   if (!argp1) {
10359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10360     return 0;
10361   }
10362   arg1 = *argp1;
10363   argp2 = (Dali::Degree *)jarg2;
10364   if (!argp2) {
10365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10366     return 0;
10367   }
10368   arg2 = *argp2;
10369   {
10370     try {
10371       result = (bool)Dali::operator !=(arg1,arg2);
10372     } catch (std::out_of_range& e) {
10373       {
10374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (std::exception& e) {
10377       {
10378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10379       };
10380     } catch (Dali::DaliException e) {
10381       {
10382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10383       };
10384     } catch (...) {
10385       {
10386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10387       };
10388     }
10389   }
10390
10391   jresult = result;
10392   return jresult;
10393 }
10394
10395
10396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10397   unsigned int jresult ;
10398   Dali::Degree arg1 ;
10399   Dali::Radian arg2 ;
10400   Dali::Degree *argp1 ;
10401   Dali::Radian *argp2 ;
10402   bool result;
10403
10404   argp1 = (Dali::Degree *)jarg1;
10405   if (!argp1) {
10406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10407     return 0;
10408   }
10409   arg1 = *argp1;
10410   argp2 = (Dali::Radian *)jarg2;
10411   if (!argp2) {
10412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10413     return 0;
10414   }
10415   arg2 = *argp2;
10416   {
10417     try {
10418       result = (bool)Dali::operator ==(arg1,arg2);
10419     } catch (std::out_of_range& e) {
10420       {
10421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10422       };
10423     } catch (std::exception& e) {
10424       {
10425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10426       };
10427     } catch (Dali::DaliException e) {
10428       {
10429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10430       };
10431     } catch (...) {
10432       {
10433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10434       };
10435     }
10436   }
10437
10438   jresult = result;
10439   return jresult;
10440 }
10441
10442
10443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10444   unsigned int jresult ;
10445   Dali::Degree arg1 ;
10446   Dali::Radian arg2 ;
10447   Dali::Degree *argp1 ;
10448   Dali::Radian *argp2 ;
10449   bool result;
10450
10451   argp1 = (Dali::Degree *)jarg1;
10452   if (!argp1) {
10453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10454     return 0;
10455   }
10456   arg1 = *argp1;
10457   argp2 = (Dali::Radian *)jarg2;
10458   if (!argp2) {
10459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10460     return 0;
10461   }
10462   arg2 = *argp2;
10463   {
10464     try {
10465       result = (bool)Dali::operator !=(arg1,arg2);
10466     } catch (std::out_of_range& e) {
10467       {
10468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10469       };
10470     } catch (std::exception& e) {
10471       {
10472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10473       };
10474     } catch (Dali::DaliException e) {
10475       {
10476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10477       };
10478     } catch (...) {
10479       {
10480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10481       };
10482     }
10483   }
10484
10485   jresult = result;
10486   return jresult;
10487 }
10488
10489
10490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10491   unsigned int jresult ;
10492   Dali::Radian arg1 ;
10493   Dali::Radian arg2 ;
10494   Dali::Radian *argp1 ;
10495   Dali::Radian *argp2 ;
10496   bool result;
10497
10498   argp1 = (Dali::Radian *)jarg1;
10499   if (!argp1) {
10500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10501     return 0;
10502   }
10503   arg1 = *argp1;
10504   argp2 = (Dali::Radian *)jarg2;
10505   if (!argp2) {
10506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10507     return 0;
10508   }
10509   arg2 = *argp2;
10510   {
10511     try {
10512       result = (bool)Dali::operator >(arg1,arg2);
10513     } catch (std::out_of_range& e) {
10514       {
10515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10516       };
10517     } catch (std::exception& e) {
10518       {
10519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10520       };
10521     } catch (Dali::DaliException e) {
10522       {
10523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10524       };
10525     } catch (...) {
10526       {
10527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10528       };
10529     }
10530   }
10531
10532   jresult = result;
10533   return jresult;
10534 }
10535
10536
10537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10538   unsigned int jresult ;
10539   Dali::Radian arg1 ;
10540   Dali::Degree arg2 ;
10541   Dali::Radian *argp1 ;
10542   Dali::Degree *argp2 ;
10543   bool result;
10544
10545   argp1 = (Dali::Radian *)jarg1;
10546   if (!argp1) {
10547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10548     return 0;
10549   }
10550   arg1 = *argp1;
10551   argp2 = (Dali::Degree *)jarg2;
10552   if (!argp2) {
10553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10554     return 0;
10555   }
10556   arg2 = *argp2;
10557   {
10558     try {
10559       result = (bool)Dali::operator >(arg1,arg2);
10560     } catch (std::out_of_range& e) {
10561       {
10562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10563       };
10564     } catch (std::exception& e) {
10565       {
10566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10567       };
10568     } catch (Dali::DaliException e) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10571       };
10572     } catch (...) {
10573       {
10574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10575       };
10576     }
10577   }
10578
10579   jresult = result;
10580   return jresult;
10581 }
10582
10583
10584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10585   unsigned int jresult ;
10586   Dali::Degree arg1 ;
10587   Dali::Radian arg2 ;
10588   Dali::Degree *argp1 ;
10589   Dali::Radian *argp2 ;
10590   bool result;
10591
10592   argp1 = (Dali::Degree *)jarg1;
10593   if (!argp1) {
10594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10595     return 0;
10596   }
10597   arg1 = *argp1;
10598   argp2 = (Dali::Radian *)jarg2;
10599   if (!argp2) {
10600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10601     return 0;
10602   }
10603   arg2 = *argp2;
10604   {
10605     try {
10606       result = (bool)Dali::operator >(arg1,arg2);
10607     } catch (std::out_of_range& e) {
10608       {
10609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10610       };
10611     } catch (std::exception& e) {
10612       {
10613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10614       };
10615     } catch (Dali::DaliException e) {
10616       {
10617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10618       };
10619     } catch (...) {
10620       {
10621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10622       };
10623     }
10624   }
10625
10626   jresult = result;
10627   return jresult;
10628 }
10629
10630
10631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10632   unsigned int jresult ;
10633   Dali::Radian arg1 ;
10634   Dali::Radian arg2 ;
10635   Dali::Radian *argp1 ;
10636   Dali::Radian *argp2 ;
10637   bool result;
10638
10639   argp1 = (Dali::Radian *)jarg1;
10640   if (!argp1) {
10641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10642     return 0;
10643   }
10644   arg1 = *argp1;
10645   argp2 = (Dali::Radian *)jarg2;
10646   if (!argp2) {
10647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10648     return 0;
10649   }
10650   arg2 = *argp2;
10651   {
10652     try {
10653       result = (bool)Dali::operator <(arg1,arg2);
10654     } catch (std::out_of_range& e) {
10655       {
10656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10657       };
10658     } catch (std::exception& e) {
10659       {
10660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10661       };
10662     } catch (Dali::DaliException e) {
10663       {
10664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10665       };
10666     } catch (...) {
10667       {
10668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10669       };
10670     }
10671   }
10672
10673   jresult = result;
10674   return jresult;
10675 }
10676
10677
10678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10679   unsigned int jresult ;
10680   Dali::Radian arg1 ;
10681   Dali::Degree arg2 ;
10682   Dali::Radian *argp1 ;
10683   Dali::Degree *argp2 ;
10684   bool result;
10685
10686   argp1 = (Dali::Radian *)jarg1;
10687   if (!argp1) {
10688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10689     return 0;
10690   }
10691   arg1 = *argp1;
10692   argp2 = (Dali::Degree *)jarg2;
10693   if (!argp2) {
10694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10695     return 0;
10696   }
10697   arg2 = *argp2;
10698   {
10699     try {
10700       result = (bool)Dali::operator <(arg1,arg2);
10701     } catch (std::out_of_range& e) {
10702       {
10703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10704       };
10705     } catch (std::exception& e) {
10706       {
10707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10708       };
10709     } catch (Dali::DaliException e) {
10710       {
10711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10712       };
10713     } catch (...) {
10714       {
10715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10716       };
10717     }
10718   }
10719
10720   jresult = result;
10721   return jresult;
10722 }
10723
10724
10725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10726   unsigned int jresult ;
10727   Dali::Degree arg1 ;
10728   Dali::Radian arg2 ;
10729   Dali::Degree *argp1 ;
10730   Dali::Radian *argp2 ;
10731   bool result;
10732
10733   argp1 = (Dali::Degree *)jarg1;
10734   if (!argp1) {
10735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10736     return 0;
10737   }
10738   arg1 = *argp1;
10739   argp2 = (Dali::Radian *)jarg2;
10740   if (!argp2) {
10741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10742     return 0;
10743   }
10744   arg2 = *argp2;
10745   {
10746     try {
10747       result = (bool)Dali::operator <(arg1,arg2);
10748     } catch (std::out_of_range& e) {
10749       {
10750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10751       };
10752     } catch (std::exception& e) {
10753       {
10754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10755       };
10756     } catch (Dali::DaliException e) {
10757       {
10758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10759       };
10760     } catch (...) {
10761       {
10762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10763       };
10764     }
10765   }
10766
10767   jresult = result;
10768   return jresult;
10769 }
10770
10771
10772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10773   void * jresult ;
10774   Dali::Radian arg1 ;
10775   float arg2 ;
10776   Dali::Radian *argp1 ;
10777   Dali::Radian result;
10778
10779   argp1 = (Dali::Radian *)jarg1;
10780   if (!argp1) {
10781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10782     return 0;
10783   }
10784   arg1 = *argp1;
10785   arg2 = (float)jarg2;
10786   {
10787     try {
10788       result = Dali::operator *(arg1,arg2);
10789     } catch (std::out_of_range& e) {
10790       {
10791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10792       };
10793     } catch (std::exception& e) {
10794       {
10795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10796       };
10797     } catch (Dali::DaliException e) {
10798       {
10799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10800       };
10801     } catch (...) {
10802       {
10803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10804       };
10805     }
10806   }
10807
10808   jresult = new Dali::Radian((const Dali::Radian &)result);
10809   return jresult;
10810 }
10811
10812
10813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10814   void * jresult ;
10815   Dali::Radian arg1 ;
10816   Dali::Radian *argp1 ;
10817   Dali::Radian result;
10818
10819   argp1 = (Dali::Radian *)jarg1;
10820   if (!argp1) {
10821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10822     return 0;
10823   }
10824   arg1 = *argp1;
10825   {
10826     try {
10827       result = Dali::operator -(arg1);
10828     } catch (std::out_of_range& e) {
10829       {
10830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10831       };
10832     } catch (std::exception& e) {
10833       {
10834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10835       };
10836     } catch (Dali::DaliException e) {
10837       {
10838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10839       };
10840     } catch (...) {
10841       {
10842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10843       };
10844     }
10845   }
10846
10847   jresult = new Dali::Radian((const Dali::Radian &)result);
10848   return jresult;
10849 }
10850
10851
10852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10853   void * jresult ;
10854   Dali::Radian arg1 ;
10855   float arg2 ;
10856   float arg3 ;
10857   Dali::Radian *argp1 ;
10858   Dali::Radian result;
10859
10860   argp1 = (Dali::Radian *)jarg1;
10861   if (!argp1) {
10862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10863     return 0;
10864   }
10865   arg1 = *argp1;
10866   arg2 = (float)jarg2;
10867   arg3 = (float)jarg3;
10868   {
10869     try {
10870       result = Dali::Clamp(arg1,arg2,arg3);
10871     } catch (std::out_of_range& e) {
10872       {
10873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10874       };
10875     } catch (std::exception& e) {
10876       {
10877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10878       };
10879     } catch (Dali::DaliException e) {
10880       {
10881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10882       };
10883     } catch (...) {
10884       {
10885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10886       };
10887     }
10888   }
10889
10890   jresult = new Dali::Radian((const Dali::Radian &)result);
10891   return jresult;
10892 }
10893
10894
10895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10896   void * jresult ;
10897   Dali::Quaternion *result = 0 ;
10898
10899   {
10900     try {
10901       result = (Dali::Quaternion *)new Dali::Quaternion();
10902     } catch (std::out_of_range& e) {
10903       {
10904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10905       };
10906     } catch (std::exception& e) {
10907       {
10908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10909       };
10910     } catch (Dali::DaliException e) {
10911       {
10912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10913       };
10914     } catch (...) {
10915       {
10916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10917       };
10918     }
10919   }
10920
10921   jresult = (void *)result;
10922   return jresult;
10923 }
10924
10925
10926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10927   void * jresult ;
10928   Dali::Radian arg1 ;
10929   Dali::Vector3 *arg2 = 0 ;
10930   Dali::Radian *argp1 ;
10931   Dali::Quaternion *result = 0 ;
10932
10933   argp1 = (Dali::Radian *)jarg1;
10934   if (!argp1) {
10935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10936     return 0;
10937   }
10938   arg1 = *argp1;
10939   arg2 = (Dali::Vector3 *)jarg2;
10940   if (!arg2) {
10941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10942     return 0;
10943   }
10944   {
10945     try {
10946       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10947     } catch (std::out_of_range& e) {
10948       {
10949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10950       };
10951     } catch (std::exception& e) {
10952       {
10953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10954       };
10955     } catch (Dali::DaliException e) {
10956       {
10957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10958       };
10959     } catch (...) {
10960       {
10961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10962       };
10963     }
10964   }
10965
10966   jresult = (void *)result;
10967   return jresult;
10968 }
10969
10970
10971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10972   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10973
10974   arg1 = (Dali::Quaternion *)jarg1;
10975   {
10976     try {
10977       delete arg1;
10978     } catch (std::out_of_range& e) {
10979       {
10980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10981       };
10982     } catch (std::exception& e) {
10983       {
10984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10985       };
10986     } catch (Dali::DaliException e) {
10987       {
10988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10989       };
10990     } catch (...) {
10991       {
10992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10993       };
10994     }
10995   }
10996
10997 }
10998
10999
11000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11001   void * jresult ;
11002   Dali::Quaternion *result = 0 ;
11003
11004   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11005   jresult = (void *)result;
11006   return jresult;
11007 }
11008
11009
11010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11011   unsigned int jresult ;
11012   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11013   bool result;
11014
11015   arg1 = (Dali::Quaternion *)jarg1;
11016   {
11017     try {
11018       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11019     } catch (std::out_of_range& e) {
11020       {
11021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11022       };
11023     } catch (std::exception& e) {
11024       {
11025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11026       };
11027     } catch (Dali::DaliException e) {
11028       {
11029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11030       };
11031     } catch (...) {
11032       {
11033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11034       };
11035     }
11036   }
11037
11038   jresult = result;
11039   return jresult;
11040 }
11041
11042
11043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11044   unsigned int jresult ;
11045   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11046   Dali::Vector3 *arg2 = 0 ;
11047   Dali::Radian *arg3 = 0 ;
11048   bool result;
11049
11050   arg1 = (Dali::Quaternion *)jarg1;
11051   arg2 = (Dali::Vector3 *)jarg2;
11052   if (!arg2) {
11053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11054     return 0;
11055   }
11056   arg3 = (Dali::Radian *)jarg3;
11057   if (!arg3) {
11058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11059     return 0;
11060   }
11061   {
11062     try {
11063       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11064     } catch (std::out_of_range& e) {
11065       {
11066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11067       };
11068     } catch (std::exception& e) {
11069       {
11070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11071       };
11072     } catch (Dali::DaliException e) {
11073       {
11074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11075       };
11076     } catch (...) {
11077       {
11078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11079       };
11080     }
11081   }
11082
11083   jresult = result;
11084   return jresult;
11085 }
11086
11087
11088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11089   void * jresult ;
11090   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11091   Dali::Quaternion *arg2 = 0 ;
11092   Dali::Quaternion result;
11093
11094   arg1 = (Dali::Quaternion *)jarg1;
11095   arg2 = (Dali::Quaternion *)jarg2;
11096   if (!arg2) {
11097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11098     return 0;
11099   }
11100   {
11101     try {
11102       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11103     } catch (std::out_of_range& e) {
11104       {
11105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11106       };
11107     } catch (std::exception& e) {
11108       {
11109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11110       };
11111     } catch (Dali::DaliException e) {
11112       {
11113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11114       };
11115     } catch (...) {
11116       {
11117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11118       };
11119     }
11120   }
11121
11122   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11123   return jresult;
11124 }
11125
11126
11127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11128   void * jresult ;
11129   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11130   Dali::Quaternion *arg2 = 0 ;
11131   Dali::Quaternion result;
11132
11133   arg1 = (Dali::Quaternion *)jarg1;
11134   arg2 = (Dali::Quaternion *)jarg2;
11135   if (!arg2) {
11136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11137     return 0;
11138   }
11139   {
11140     try {
11141       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11142     } catch (std::out_of_range& e) {
11143       {
11144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11145       };
11146     } catch (std::exception& e) {
11147       {
11148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11149       };
11150     } catch (Dali::DaliException e) {
11151       {
11152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11153       };
11154     } catch (...) {
11155       {
11156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11157       };
11158     }
11159   }
11160
11161   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11162   return jresult;
11163 }
11164
11165
11166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11167   void * jresult ;
11168   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11169   Dali::Quaternion *arg2 = 0 ;
11170   Dali::Quaternion result;
11171
11172   arg1 = (Dali::Quaternion *)jarg1;
11173   arg2 = (Dali::Quaternion *)jarg2;
11174   if (!arg2) {
11175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11176     return 0;
11177   }
11178   {
11179     try {
11180       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11181     } catch (std::out_of_range& e) {
11182       {
11183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11184       };
11185     } catch (std::exception& e) {
11186       {
11187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11188       };
11189     } catch (Dali::DaliException e) {
11190       {
11191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11192       };
11193     } catch (...) {
11194       {
11195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11196       };
11197     }
11198   }
11199
11200   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11201   return jresult;
11202 }
11203
11204
11205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11206   void * jresult ;
11207   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11208   Dali::Vector3 *arg2 = 0 ;
11209   Dali::Vector3 result;
11210
11211   arg1 = (Dali::Quaternion *)jarg1;
11212   arg2 = (Dali::Vector3 *)jarg2;
11213   if (!arg2) {
11214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11215     return 0;
11216   }
11217   {
11218     try {
11219       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11220     } catch (std::out_of_range& e) {
11221       {
11222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11223       };
11224     } catch (std::exception& e) {
11225       {
11226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11227       };
11228     } catch (Dali::DaliException e) {
11229       {
11230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11231       };
11232     } catch (...) {
11233       {
11234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11235       };
11236     }
11237   }
11238
11239   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11240   return jresult;
11241 }
11242
11243
11244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11245   void * jresult ;
11246   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11247   Dali::Quaternion *arg2 = 0 ;
11248   Dali::Quaternion result;
11249
11250   arg1 = (Dali::Quaternion *)jarg1;
11251   arg2 = (Dali::Quaternion *)jarg2;
11252   if (!arg2) {
11253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11254     return 0;
11255   }
11256   {
11257     try {
11258       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11259     } catch (std::out_of_range& e) {
11260       {
11261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11262       };
11263     } catch (std::exception& e) {
11264       {
11265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11266       };
11267     } catch (Dali::DaliException e) {
11268       {
11269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11270       };
11271     } catch (...) {
11272       {
11273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11274       };
11275     }
11276   }
11277
11278   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11279   return jresult;
11280 }
11281
11282
11283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11284   void * jresult ;
11285   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11286   float arg2 ;
11287   Dali::Quaternion result;
11288
11289   arg1 = (Dali::Quaternion *)jarg1;
11290   arg2 = (float)jarg2;
11291   {
11292     try {
11293       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11294     } catch (std::out_of_range& e) {
11295       {
11296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11297       };
11298     } catch (std::exception& e) {
11299       {
11300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11301       };
11302     } catch (Dali::DaliException e) {
11303       {
11304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11305       };
11306     } catch (...) {
11307       {
11308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11309       };
11310     }
11311   }
11312
11313   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11314   return jresult;
11315 }
11316
11317
11318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11319   void * jresult ;
11320   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11321   float arg2 ;
11322   Dali::Quaternion result;
11323
11324   arg1 = (Dali::Quaternion *)jarg1;
11325   arg2 = (float)jarg2;
11326   {
11327     try {
11328       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11329     } catch (std::out_of_range& e) {
11330       {
11331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11332       };
11333     } catch (std::exception& e) {
11334       {
11335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11336       };
11337     } catch (Dali::DaliException e) {
11338       {
11339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11340       };
11341     } catch (...) {
11342       {
11343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11344       };
11345     }
11346   }
11347
11348   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11349   return jresult;
11350 }
11351
11352
11353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11354   void * jresult ;
11355   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11356   Dali::Quaternion result;
11357
11358   arg1 = (Dali::Quaternion *)jarg1;
11359   {
11360     try {
11361       result = ((Dali::Quaternion const *)arg1)->operator -();
11362     } catch (std::out_of_range& e) {
11363       {
11364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11365       };
11366     } catch (std::exception& e) {
11367       {
11368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11369       };
11370     } catch (Dali::DaliException e) {
11371       {
11372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11373       };
11374     } catch (...) {
11375       {
11376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11377       };
11378     }
11379   }
11380
11381   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11382   return jresult;
11383 }
11384
11385
11386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11387   void * jresult ;
11388   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11389   Dali::Quaternion *arg2 = 0 ;
11390   Dali::Quaternion *result = 0 ;
11391
11392   arg1 = (Dali::Quaternion *)jarg1;
11393   arg2 = (Dali::Quaternion *)jarg2;
11394   if (!arg2) {
11395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11396     return 0;
11397   }
11398   {
11399     try {
11400       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11401     } catch (std::out_of_range& e) {
11402       {
11403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11404       };
11405     } catch (std::exception& e) {
11406       {
11407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11408       };
11409     } catch (Dali::DaliException e) {
11410       {
11411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11412       };
11413     } catch (...) {
11414       {
11415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11416       };
11417     }
11418   }
11419
11420   jresult = (void *)result;
11421   return jresult;
11422 }
11423
11424
11425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11426   void * jresult ;
11427   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11428   Dali::Quaternion *arg2 = 0 ;
11429   Dali::Quaternion *result = 0 ;
11430
11431   arg1 = (Dali::Quaternion *)jarg1;
11432   arg2 = (Dali::Quaternion *)jarg2;
11433   if (!arg2) {
11434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11435     return 0;
11436   }
11437   {
11438     try {
11439       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11440     } catch (std::out_of_range& e) {
11441       {
11442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11443       };
11444     } catch (std::exception& e) {
11445       {
11446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11447       };
11448     } catch (Dali::DaliException e) {
11449       {
11450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11451       };
11452     } catch (...) {
11453       {
11454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11455       };
11456     }
11457   }
11458
11459   jresult = (void *)result;
11460   return jresult;
11461 }
11462
11463
11464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11465   void * jresult ;
11466   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11467   Dali::Quaternion *arg2 = 0 ;
11468   Dali::Quaternion *result = 0 ;
11469
11470   arg1 = (Dali::Quaternion *)jarg1;
11471   arg2 = (Dali::Quaternion *)jarg2;
11472   if (!arg2) {
11473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11474     return 0;
11475   }
11476   {
11477     try {
11478       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11479     } catch (std::out_of_range& e) {
11480       {
11481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11482       };
11483     } catch (std::exception& e) {
11484       {
11485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11486       };
11487     } catch (Dali::DaliException e) {
11488       {
11489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11490       };
11491     } catch (...) {
11492       {
11493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11494       };
11495     }
11496   }
11497
11498   jresult = (void *)result;
11499   return jresult;
11500 }
11501
11502
11503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11504   void * jresult ;
11505   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11506   float arg2 ;
11507   Dali::Quaternion *result = 0 ;
11508
11509   arg1 = (Dali::Quaternion *)jarg1;
11510   arg2 = (float)jarg2;
11511   {
11512     try {
11513       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11514     } catch (std::out_of_range& e) {
11515       {
11516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11517       };
11518     } catch (std::exception& e) {
11519       {
11520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11521       };
11522     } catch (Dali::DaliException e) {
11523       {
11524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11525       };
11526     } catch (...) {
11527       {
11528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11529       };
11530     }
11531   }
11532
11533   jresult = (void *)result;
11534   return jresult;
11535 }
11536
11537
11538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11539   void * jresult ;
11540   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11541   float arg2 ;
11542   Dali::Quaternion *result = 0 ;
11543
11544   arg1 = (Dali::Quaternion *)jarg1;
11545   arg2 = (float)jarg2;
11546   {
11547     try {
11548       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11549     } catch (std::out_of_range& e) {
11550       {
11551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11552       };
11553     } catch (std::exception& e) {
11554       {
11555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11556       };
11557     } catch (Dali::DaliException e) {
11558       {
11559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11560       };
11561     } catch (...) {
11562       {
11563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11564       };
11565     }
11566   }
11567
11568   jresult = (void *)result;
11569   return jresult;
11570 }
11571
11572
11573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11574   unsigned int jresult ;
11575   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11576   Dali::Quaternion *arg2 = 0 ;
11577   bool result;
11578
11579   arg1 = (Dali::Quaternion *)jarg1;
11580   arg2 = (Dali::Quaternion *)jarg2;
11581   if (!arg2) {
11582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11583     return 0;
11584   }
11585   {
11586     try {
11587       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11588     } catch (std::out_of_range& e) {
11589       {
11590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11591       };
11592     } catch (std::exception& e) {
11593       {
11594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11595       };
11596     } catch (Dali::DaliException e) {
11597       {
11598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11599       };
11600     } catch (...) {
11601       {
11602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11603       };
11604     }
11605   }
11606
11607   jresult = result;
11608   return jresult;
11609 }
11610
11611
11612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11613   unsigned int jresult ;
11614   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11615   Dali::Quaternion *arg2 = 0 ;
11616   bool result;
11617
11618   arg1 = (Dali::Quaternion *)jarg1;
11619   arg2 = (Dali::Quaternion *)jarg2;
11620   if (!arg2) {
11621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11622     return 0;
11623   }
11624   {
11625     try {
11626       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11627     } catch (std::out_of_range& e) {
11628       {
11629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11630       };
11631     } catch (std::exception& e) {
11632       {
11633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11634       };
11635     } catch (Dali::DaliException e) {
11636       {
11637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11638       };
11639     } catch (...) {
11640       {
11641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11642       };
11643     }
11644   }
11645
11646   jresult = result;
11647   return jresult;
11648 }
11649
11650
11651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11652   float jresult ;
11653   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11654   float result;
11655
11656   arg1 = (Dali::Quaternion *)jarg1;
11657   {
11658     try {
11659       result = (float)((Dali::Quaternion const *)arg1)->Length();
11660     } catch (std::out_of_range& e) {
11661       {
11662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11663       };
11664     } catch (std::exception& e) {
11665       {
11666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11667       };
11668     } catch (Dali::DaliException e) {
11669       {
11670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11671       };
11672     } catch (...) {
11673       {
11674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11675       };
11676     }
11677   }
11678
11679   jresult = result;
11680   return jresult;
11681 }
11682
11683
11684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11685   float jresult ;
11686   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11687   float result;
11688
11689   arg1 = (Dali::Quaternion *)jarg1;
11690   {
11691     try {
11692       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11693     } catch (std::out_of_range& e) {
11694       {
11695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11696       };
11697     } catch (std::exception& e) {
11698       {
11699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11700       };
11701     } catch (Dali::DaliException e) {
11702       {
11703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11704       };
11705     } catch (...) {
11706       {
11707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11708       };
11709     }
11710   }
11711
11712   jresult = result;
11713   return jresult;
11714 }
11715
11716
11717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11718   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11719
11720   arg1 = (Dali::Quaternion *)jarg1;
11721   {
11722     try {
11723       (arg1)->Normalize();
11724     } catch (std::out_of_range& e) {
11725       {
11726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11727       };
11728     } catch (std::exception& e) {
11729       {
11730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11731       };
11732     } catch (Dali::DaliException e) {
11733       {
11734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11735       };
11736     } catch (...) {
11737       {
11738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11739       };
11740     }
11741   }
11742
11743 }
11744
11745
11746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11747   void * jresult ;
11748   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11749   Dali::Quaternion result;
11750
11751   arg1 = (Dali::Quaternion *)jarg1;
11752   {
11753     try {
11754       result = ((Dali::Quaternion const *)arg1)->Normalized();
11755     } catch (std::out_of_range& e) {
11756       {
11757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11758       };
11759     } catch (std::exception& e) {
11760       {
11761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11762       };
11763     } catch (Dali::DaliException e) {
11764       {
11765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11766       };
11767     } catch (...) {
11768       {
11769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11770       };
11771     }
11772   }
11773
11774   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11775   return jresult;
11776 }
11777
11778
11779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11780   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11781
11782   arg1 = (Dali::Quaternion *)jarg1;
11783   {
11784     try {
11785       (arg1)->Conjugate();
11786     } catch (std::out_of_range& e) {
11787       {
11788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11789       };
11790     } catch (std::exception& e) {
11791       {
11792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11793       };
11794     } catch (Dali::DaliException e) {
11795       {
11796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11797       };
11798     } catch (...) {
11799       {
11800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11801       };
11802     }
11803   }
11804
11805 }
11806
11807
11808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11809   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11810
11811   arg1 = (Dali::Quaternion *)jarg1;
11812   {
11813     try {
11814       (arg1)->Invert();
11815     } catch (std::out_of_range& e) {
11816       {
11817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11818       };
11819     } catch (std::exception& e) {
11820       {
11821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11822       };
11823     } catch (Dali::DaliException e) {
11824       {
11825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11826       };
11827     } catch (...) {
11828       {
11829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11830       };
11831     }
11832   }
11833
11834 }
11835
11836
11837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11838   void * jresult ;
11839   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11840   Dali::Quaternion result;
11841
11842   arg1 = (Dali::Quaternion *)jarg1;
11843   {
11844     try {
11845       result = ((Dali::Quaternion const *)arg1)->Log();
11846     } catch (std::out_of_range& e) {
11847       {
11848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11849       };
11850     } catch (std::exception& e) {
11851       {
11852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11853       };
11854     } catch (Dali::DaliException e) {
11855       {
11856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11857       };
11858     } catch (...) {
11859       {
11860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11861       };
11862     }
11863   }
11864
11865   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11866   return jresult;
11867 }
11868
11869
11870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11871   void * jresult ;
11872   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11873   Dali::Quaternion result;
11874
11875   arg1 = (Dali::Quaternion *)jarg1;
11876   {
11877     try {
11878       result = ((Dali::Quaternion const *)arg1)->Exp();
11879     } catch (std::out_of_range& e) {
11880       {
11881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11882       };
11883     } catch (std::exception& e) {
11884       {
11885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11886       };
11887     } catch (Dali::DaliException e) {
11888       {
11889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11890       };
11891     } catch (...) {
11892       {
11893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11894       };
11895     }
11896   }
11897
11898   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11899   return jresult;
11900 }
11901
11902
11903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11904   float jresult ;
11905   Dali::Quaternion *arg1 = 0 ;
11906   Dali::Quaternion *arg2 = 0 ;
11907   float result;
11908
11909   arg1 = (Dali::Quaternion *)jarg1;
11910   if (!arg1) {
11911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11912     return 0;
11913   }
11914   arg2 = (Dali::Quaternion *)jarg2;
11915   if (!arg2) {
11916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11917     return 0;
11918   }
11919   {
11920     try {
11921       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11922     } catch (std::out_of_range& e) {
11923       {
11924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11925       };
11926     } catch (std::exception& e) {
11927       {
11928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11929       };
11930     } catch (Dali::DaliException e) {
11931       {
11932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11933       };
11934     } catch (...) {
11935       {
11936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11937       };
11938     }
11939   }
11940
11941   jresult = result;
11942   return jresult;
11943 }
11944
11945
11946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11947   void * jresult ;
11948   Dali::Quaternion *arg1 = 0 ;
11949   Dali::Quaternion *arg2 = 0 ;
11950   float arg3 ;
11951   Dali::Quaternion result;
11952
11953   arg1 = (Dali::Quaternion *)jarg1;
11954   if (!arg1) {
11955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11956     return 0;
11957   }
11958   arg2 = (Dali::Quaternion *)jarg2;
11959   if (!arg2) {
11960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11961     return 0;
11962   }
11963   arg3 = (float)jarg3;
11964   {
11965     try {
11966       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11967     } catch (std::out_of_range& e) {
11968       {
11969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11970       };
11971     } catch (std::exception& e) {
11972       {
11973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11974       };
11975     } catch (Dali::DaliException e) {
11976       {
11977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11978       };
11979     } catch (...) {
11980       {
11981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11982       };
11983     }
11984   }
11985
11986   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11987   return jresult;
11988 }
11989
11990
11991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11992   void * jresult ;
11993   Dali::Quaternion *arg1 = 0 ;
11994   Dali::Quaternion *arg2 = 0 ;
11995   float arg3 ;
11996   Dali::Quaternion result;
11997
11998   arg1 = (Dali::Quaternion *)jarg1;
11999   if (!arg1) {
12000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12001     return 0;
12002   }
12003   arg2 = (Dali::Quaternion *)jarg2;
12004   if (!arg2) {
12005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12006     return 0;
12007   }
12008   arg3 = (float)jarg3;
12009   {
12010     try {
12011       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12012     } catch (std::out_of_range& e) {
12013       {
12014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12015       };
12016     } catch (std::exception& e) {
12017       {
12018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12019       };
12020     } catch (Dali::DaliException e) {
12021       {
12022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12023       };
12024     } catch (...) {
12025       {
12026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12027       };
12028     }
12029   }
12030
12031   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12032   return jresult;
12033 }
12034
12035
12036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12037   void * jresult ;
12038   Dali::Quaternion *arg1 = 0 ;
12039   Dali::Quaternion *arg2 = 0 ;
12040   float arg3 ;
12041   Dali::Quaternion result;
12042
12043   arg1 = (Dali::Quaternion *)jarg1;
12044   if (!arg1) {
12045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12046     return 0;
12047   }
12048   arg2 = (Dali::Quaternion *)jarg2;
12049   if (!arg2) {
12050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12051     return 0;
12052   }
12053   arg3 = (float)jarg3;
12054   {
12055     try {
12056       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12057     } catch (std::out_of_range& e) {
12058       {
12059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12060       };
12061     } catch (std::exception& e) {
12062       {
12063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12064       };
12065     } catch (Dali::DaliException e) {
12066       {
12067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12068       };
12069     } catch (...) {
12070       {
12071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12072       };
12073     }
12074   }
12075
12076   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12077   return jresult;
12078 }
12079
12080
12081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12082   void * jresult ;
12083   Dali::Quaternion *arg1 = 0 ;
12084   Dali::Quaternion *arg2 = 0 ;
12085   Dali::Quaternion *arg3 = 0 ;
12086   Dali::Quaternion *arg4 = 0 ;
12087   float arg5 ;
12088   Dali::Quaternion result;
12089
12090   arg1 = (Dali::Quaternion *)jarg1;
12091   if (!arg1) {
12092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12093     return 0;
12094   }
12095   arg2 = (Dali::Quaternion *)jarg2;
12096   if (!arg2) {
12097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12098     return 0;
12099   }
12100   arg3 = (Dali::Quaternion *)jarg3;
12101   if (!arg3) {
12102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12103     return 0;
12104   }
12105   arg4 = (Dali::Quaternion *)jarg4;
12106   if (!arg4) {
12107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12108     return 0;
12109   }
12110   arg5 = (float)jarg5;
12111   {
12112     try {
12113       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12114     } catch (std::out_of_range& e) {
12115       {
12116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (std::exception& e) {
12119       {
12120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12121       };
12122     } catch (Dali::DaliException e) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12125       };
12126     } catch (...) {
12127       {
12128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12129       };
12130     }
12131   }
12132
12133   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12134   return jresult;
12135 }
12136
12137
12138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12139   float jresult ;
12140   Dali::Quaternion *arg1 = 0 ;
12141   Dali::Quaternion *arg2 = 0 ;
12142   float result;
12143
12144   arg1 = (Dali::Quaternion *)jarg1;
12145   if (!arg1) {
12146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12147     return 0;
12148   }
12149   arg2 = (Dali::Quaternion *)jarg2;
12150   if (!arg2) {
12151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12152     return 0;
12153   }
12154   {
12155     try {
12156       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12157     } catch (std::out_of_range& e) {
12158       {
12159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12160       };
12161     } catch (std::exception& e) {
12162       {
12163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12164       };
12165     } catch (Dali::DaliException e) {
12166       {
12167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12168       };
12169     } catch (...) {
12170       {
12171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12172       };
12173     }
12174   }
12175
12176   jresult = result;
12177   return jresult;
12178 }
12179
12180
12181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12182   void * jresult ;
12183   Dali::Matrix *result = 0 ;
12184
12185   {
12186     try {
12187       result = (Dali::Matrix *)new Dali::Matrix();
12188     } catch (std::out_of_range& e) {
12189       {
12190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12191       };
12192     } catch (std::exception& e) {
12193       {
12194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12195       };
12196     } catch (Dali::DaliException e) {
12197       {
12198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12199       };
12200     } catch (...) {
12201       {
12202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12203       };
12204     }
12205   }
12206
12207   jresult = (void *)result;
12208   return jresult;
12209 }
12210
12211
12212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12213   void * jresult ;
12214   bool arg1 ;
12215   Dali::Matrix *result = 0 ;
12216
12217   arg1 = jarg1 ? true : false;
12218   {
12219     try {
12220       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12221     } catch (std::out_of_range& e) {
12222       {
12223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12224       };
12225     } catch (std::exception& e) {
12226       {
12227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12228       };
12229     } catch (Dali::DaliException e) {
12230       {
12231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12232       };
12233     } catch (...) {
12234       {
12235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12236       };
12237     }
12238   }
12239
12240   jresult = (void *)result;
12241   return jresult;
12242 }
12243
12244
12245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12246   void * jresult ;
12247   float *arg1 = (float *) 0 ;
12248   Dali::Matrix *result = 0 ;
12249
12250   arg1 = jarg1;
12251   {
12252     try {
12253       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12254     } catch (std::out_of_range& e) {
12255       {
12256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12257       };
12258     } catch (std::exception& e) {
12259       {
12260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12261       };
12262     } catch (Dali::DaliException e) {
12263       {
12264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12265       };
12266     } catch (...) {
12267       {
12268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12269       };
12270     }
12271   }
12272
12273   jresult = (void *)result;
12274
12275
12276   return jresult;
12277 }
12278
12279
12280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12281   void * jresult ;
12282   Dali::Quaternion *arg1 = 0 ;
12283   Dali::Matrix *result = 0 ;
12284
12285   arg1 = (Dali::Quaternion *)jarg1;
12286   if (!arg1) {
12287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12288     return 0;
12289   }
12290   {
12291     try {
12292       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12293     } catch (std::out_of_range& e) {
12294       {
12295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12296       };
12297     } catch (std::exception& e) {
12298       {
12299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12300       };
12301     } catch (Dali::DaliException e) {
12302       {
12303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12304       };
12305     } catch (...) {
12306       {
12307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12308       };
12309     }
12310   }
12311
12312   jresult = (void *)result;
12313   return jresult;
12314 }
12315
12316
12317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12318   void * jresult ;
12319   Dali::Matrix *arg1 = 0 ;
12320   Dali::Matrix *result = 0 ;
12321
12322   arg1 = (Dali::Matrix *)jarg1;
12323   if (!arg1) {
12324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12325     return 0;
12326   }
12327   {
12328     try {
12329       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12330     } catch (std::out_of_range& e) {
12331       {
12332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12333       };
12334     } catch (std::exception& e) {
12335       {
12336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12337       };
12338     } catch (Dali::DaliException e) {
12339       {
12340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12341       };
12342     } catch (...) {
12343       {
12344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12345       };
12346     }
12347   }
12348
12349   jresult = (void *)result;
12350   return jresult;
12351 }
12352
12353
12354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12355   void * jresult ;
12356   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12357   Dali::Matrix *arg2 = 0 ;
12358   Dali::Matrix *result = 0 ;
12359
12360   arg1 = (Dali::Matrix *)jarg1;
12361   arg2 = (Dali::Matrix *)jarg2;
12362   if (!arg2) {
12363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12364     return 0;
12365   }
12366   {
12367     try {
12368       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12369     } catch (std::out_of_range& e) {
12370       {
12371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12372       };
12373     } catch (std::exception& e) {
12374       {
12375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12376       };
12377     } catch (Dali::DaliException e) {
12378       {
12379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12380       };
12381     } catch (...) {
12382       {
12383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12384       };
12385     }
12386   }
12387
12388   jresult = (void *)result;
12389   return jresult;
12390 }
12391
12392
12393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12394   void * jresult ;
12395   Dali::Matrix *result = 0 ;
12396
12397   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12398   jresult = (void *)result;
12399   return jresult;
12400 }
12401
12402
12403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12404   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12405
12406   arg1 = (Dali::Matrix *)jarg1;
12407   {
12408     try {
12409       (arg1)->SetIdentity();
12410     } catch (std::out_of_range& e) {
12411       {
12412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12413       };
12414     } catch (std::exception& e) {
12415       {
12416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12417       };
12418     } catch (Dali::DaliException e) {
12419       {
12420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12421       };
12422     } catch (...) {
12423       {
12424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12425       };
12426     }
12427   }
12428
12429 }
12430
12431
12432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12433   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12434   Dali::Vector3 *arg2 = 0 ;
12435
12436   arg1 = (Dali::Matrix *)jarg1;
12437   arg2 = (Dali::Vector3 *)jarg2;
12438   if (!arg2) {
12439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12440     return ;
12441   }
12442   {
12443     try {
12444       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12445     } catch (std::out_of_range& e) {
12446       {
12447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12448       };
12449     } catch (std::exception& e) {
12450       {
12451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12452       };
12453     } catch (Dali::DaliException e) {
12454       {
12455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12456       };
12457     } catch (...) {
12458       {
12459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12460       };
12461     }
12462   }
12463
12464 }
12465
12466
12467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12468   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12469   Dali::Matrix *arg2 = 0 ;
12470
12471   arg1 = (Dali::Matrix *)jarg1;
12472   arg2 = (Dali::Matrix *)jarg2;
12473   if (!arg2) {
12474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12475     return ;
12476   }
12477   {
12478     try {
12479       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12480     } catch (std::out_of_range& e) {
12481       {
12482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12483       };
12484     } catch (std::exception& e) {
12485       {
12486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12487       };
12488     } catch (Dali::DaliException e) {
12489       {
12490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12491       };
12492     } catch (...) {
12493       {
12494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12495       };
12496     }
12497   }
12498
12499 }
12500
12501
12502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12503   unsigned int jresult ;
12504   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12505   bool result;
12506
12507   arg1 = (Dali::Matrix *)jarg1;
12508   {
12509     try {
12510       result = (bool)(arg1)->Invert();
12511     } catch (std::out_of_range& e) {
12512       {
12513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12514       };
12515     } catch (std::exception& e) {
12516       {
12517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12518       };
12519     } catch (Dali::DaliException e) {
12520       {
12521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12522       };
12523     } catch (...) {
12524       {
12525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12526       };
12527     }
12528   }
12529
12530   jresult = result;
12531   return jresult;
12532 }
12533
12534
12535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12536   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12537
12538   arg1 = (Dali::Matrix *)jarg1;
12539   {
12540     try {
12541       (arg1)->Transpose();
12542     } catch (std::out_of_range& e) {
12543       {
12544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12545       };
12546     } catch (std::exception& e) {
12547       {
12548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12549       };
12550     } catch (Dali::DaliException e) {
12551       {
12552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12553       };
12554     } catch (...) {
12555       {
12556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12557       };
12558     }
12559   }
12560
12561 }
12562
12563
12564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12565   void * jresult ;
12566   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12567   Dali::Vector3 result;
12568
12569   arg1 = (Dali::Matrix *)jarg1;
12570   {
12571     try {
12572       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12573     } catch (std::out_of_range& e) {
12574       {
12575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12576       };
12577     } catch (std::exception& e) {
12578       {
12579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12580       };
12581     } catch (Dali::DaliException e) {
12582       {
12583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12584       };
12585     } catch (...) {
12586       {
12587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12588       };
12589     }
12590   }
12591
12592   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12593   return jresult;
12594 }
12595
12596
12597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12598   void * jresult ;
12599   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12600   Dali::Vector3 result;
12601
12602   arg1 = (Dali::Matrix *)jarg1;
12603   {
12604     try {
12605       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12606     } catch (std::out_of_range& e) {
12607       {
12608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12609       };
12610     } catch (std::exception& e) {
12611       {
12612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12613       };
12614     } catch (Dali::DaliException e) {
12615       {
12616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12617       };
12618     } catch (...) {
12619       {
12620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12621       };
12622     }
12623   }
12624
12625   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12626   return jresult;
12627 }
12628
12629
12630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12631   void * jresult ;
12632   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12633   Dali::Vector3 result;
12634
12635   arg1 = (Dali::Matrix *)jarg1;
12636   {
12637     try {
12638       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12639     } catch (std::out_of_range& e) {
12640       {
12641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12642       };
12643     } catch (std::exception& e) {
12644       {
12645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12646       };
12647     } catch (Dali::DaliException e) {
12648       {
12649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12650       };
12651     } catch (...) {
12652       {
12653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12654       };
12655     }
12656   }
12657
12658   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12659   return jresult;
12660 }
12661
12662
12663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12664   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12665   Dali::Vector3 *arg2 = 0 ;
12666
12667   arg1 = (Dali::Matrix *)jarg1;
12668   arg2 = (Dali::Vector3 *)jarg2;
12669   if (!arg2) {
12670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12671     return ;
12672   }
12673   {
12674     try {
12675       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12676     } catch (std::out_of_range& e) {
12677       {
12678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12679       };
12680     } catch (std::exception& e) {
12681       {
12682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12683       };
12684     } catch (Dali::DaliException e) {
12685       {
12686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12687       };
12688     } catch (...) {
12689       {
12690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12691       };
12692     }
12693   }
12694
12695 }
12696
12697
12698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12699   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12700   Dali::Vector3 *arg2 = 0 ;
12701
12702   arg1 = (Dali::Matrix *)jarg1;
12703   arg2 = (Dali::Vector3 *)jarg2;
12704   if (!arg2) {
12705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12706     return ;
12707   }
12708   {
12709     try {
12710       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12711     } catch (std::out_of_range& e) {
12712       {
12713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12714       };
12715     } catch (std::exception& e) {
12716       {
12717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12718       };
12719     } catch (Dali::DaliException e) {
12720       {
12721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12722       };
12723     } catch (...) {
12724       {
12725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12726       };
12727     }
12728   }
12729
12730 }
12731
12732
12733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12734   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12735   Dali::Vector3 *arg2 = 0 ;
12736
12737   arg1 = (Dali::Matrix *)jarg1;
12738   arg2 = (Dali::Vector3 *)jarg2;
12739   if (!arg2) {
12740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12741     return ;
12742   }
12743   {
12744     try {
12745       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12746     } catch (std::out_of_range& e) {
12747       {
12748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12749       };
12750     } catch (std::exception& e) {
12751       {
12752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12753       };
12754     } catch (Dali::DaliException e) {
12755       {
12756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12757       };
12758     } catch (...) {
12759       {
12760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12761       };
12762     }
12763   }
12764
12765 }
12766
12767
12768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12769   void * jresult ;
12770   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12771   Dali::Vector4 *result = 0 ;
12772
12773   arg1 = (Dali::Matrix *)jarg1;
12774   {
12775     try {
12776       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12777     } catch (std::out_of_range& e) {
12778       {
12779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12780       };
12781     } catch (std::exception& e) {
12782       {
12783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12784       };
12785     } catch (Dali::DaliException e) {
12786       {
12787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12788       };
12789     } catch (...) {
12790       {
12791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12792       };
12793     }
12794   }
12795
12796   jresult = (void *)result;
12797   return jresult;
12798 }
12799
12800
12801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12802   void * jresult ;
12803   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12804   Dali::Vector3 *result = 0 ;
12805
12806   arg1 = (Dali::Matrix *)jarg1;
12807   {
12808     try {
12809       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12810     } catch (std::out_of_range& e) {
12811       {
12812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12813       };
12814     } catch (std::exception& e) {
12815       {
12816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12817       };
12818     } catch (Dali::DaliException e) {
12819       {
12820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12821       };
12822     } catch (...) {
12823       {
12824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12825       };
12826     }
12827   }
12828
12829   jresult = (void *)result;
12830   return jresult;
12831 }
12832
12833
12834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12835   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12836   Dali::Vector4 *arg2 = 0 ;
12837
12838   arg1 = (Dali::Matrix *)jarg1;
12839   arg2 = (Dali::Vector4 *)jarg2;
12840   if (!arg2) {
12841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12842     return ;
12843   }
12844   {
12845     try {
12846       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12847     } catch (std::out_of_range& e) {
12848       {
12849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12850       };
12851     } catch (std::exception& e) {
12852       {
12853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12854       };
12855     } catch (Dali::DaliException e) {
12856       {
12857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12858       };
12859     } catch (...) {
12860       {
12861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12862       };
12863     }
12864   }
12865
12866 }
12867
12868
12869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12870   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12871   Dali::Vector3 *arg2 = 0 ;
12872
12873   arg1 = (Dali::Matrix *)jarg1;
12874   arg2 = (Dali::Vector3 *)jarg2;
12875   if (!arg2) {
12876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12877     return ;
12878   }
12879   {
12880     try {
12881       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12882     } catch (std::out_of_range& e) {
12883       {
12884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12885       };
12886     } catch (std::exception& e) {
12887       {
12888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12889       };
12890     } catch (Dali::DaliException e) {
12891       {
12892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12893       };
12894     } catch (...) {
12895       {
12896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12897       };
12898     }
12899   }
12900
12901 }
12902
12903
12904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12905   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12906
12907   arg1 = (Dali::Matrix *)jarg1;
12908   {
12909     try {
12910       (arg1)->OrthoNormalize();
12911     } catch (std::out_of_range& e) {
12912       {
12913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12914       };
12915     } catch (std::exception& e) {
12916       {
12917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12918       };
12919     } catch (Dali::DaliException e) {
12920       {
12921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12922       };
12923     } catch (...) {
12924       {
12925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12926       };
12927     }
12928   }
12929
12930 }
12931
12932
12933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12934   void * jresult ;
12935   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12936   float *result = 0 ;
12937
12938   arg1 = (Dali::Matrix *)jarg1;
12939   {
12940     try {
12941       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12942     } catch (std::out_of_range& e) {
12943       {
12944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12945       };
12946     } catch (std::exception& e) {
12947       {
12948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12949       };
12950     } catch (Dali::DaliException e) {
12951       {
12952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12953       };
12954     } catch (...) {
12955       {
12956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12957       };
12958     }
12959   }
12960
12961   jresult = (void *)result;
12962   return jresult;
12963 }
12964
12965
12966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12967   Dali::Matrix *arg1 = 0 ;
12968   Dali::Matrix *arg2 = 0 ;
12969   Dali::Matrix *arg3 = 0 ;
12970
12971   arg1 = (Dali::Matrix *)jarg1;
12972   if (!arg1) {
12973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12974     return ;
12975   }
12976   arg2 = (Dali::Matrix *)jarg2;
12977   if (!arg2) {
12978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12979     return ;
12980   }
12981   arg3 = (Dali::Matrix *)jarg3;
12982   if (!arg3) {
12983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12984     return ;
12985   }
12986   {
12987     try {
12988       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12989     } catch (std::out_of_range& e) {
12990       {
12991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12992       };
12993     } catch (std::exception& e) {
12994       {
12995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12996       };
12997     } catch (Dali::DaliException e) {
12998       {
12999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13000       };
13001     } catch (...) {
13002       {
13003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13004       };
13005     }
13006   }
13007
13008 }
13009
13010
13011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13012   Dali::Matrix *arg1 = 0 ;
13013   Dali::Matrix *arg2 = 0 ;
13014   Dali::Quaternion *arg3 = 0 ;
13015
13016   arg1 = (Dali::Matrix *)jarg1;
13017   if (!arg1) {
13018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13019     return ;
13020   }
13021   arg2 = (Dali::Matrix *)jarg2;
13022   if (!arg2) {
13023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13024     return ;
13025   }
13026   arg3 = (Dali::Quaternion *)jarg3;
13027   if (!arg3) {
13028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13029     return ;
13030   }
13031   {
13032     try {
13033       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13034     } catch (std::out_of_range& e) {
13035       {
13036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13037       };
13038     } catch (std::exception& e) {
13039       {
13040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13041       };
13042     } catch (Dali::DaliException e) {
13043       {
13044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13045       };
13046     } catch (...) {
13047       {
13048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13049       };
13050     }
13051   }
13052
13053 }
13054
13055
13056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13057   void * jresult ;
13058   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13059   Dali::Vector4 *arg2 = 0 ;
13060   Dali::Vector4 result;
13061
13062   arg1 = (Dali::Matrix *)jarg1;
13063   arg2 = (Dali::Vector4 *)jarg2;
13064   if (!arg2) {
13065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13066     return 0;
13067   }
13068   {
13069     try {
13070       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13071     } catch (std::out_of_range& e) {
13072       {
13073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13074       };
13075     } catch (std::exception& e) {
13076       {
13077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13078       };
13079     } catch (Dali::DaliException e) {
13080       {
13081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13082       };
13083     } catch (...) {
13084       {
13085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13086       };
13087     }
13088   }
13089
13090   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13091   return jresult;
13092 }
13093
13094
13095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13096   unsigned int jresult ;
13097   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13098   Dali::Matrix *arg2 = 0 ;
13099   bool result;
13100
13101   arg1 = (Dali::Matrix *)jarg1;
13102   arg2 = (Dali::Matrix *)jarg2;
13103   if (!arg2) {
13104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13105     return 0;
13106   }
13107   {
13108     try {
13109       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13110     } catch (std::out_of_range& e) {
13111       {
13112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13113       };
13114     } catch (std::exception& e) {
13115       {
13116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13117       };
13118     } catch (Dali::DaliException e) {
13119       {
13120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13121       };
13122     } catch (...) {
13123       {
13124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13125       };
13126     }
13127   }
13128
13129   jresult = result;
13130   return jresult;
13131 }
13132
13133
13134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13135   unsigned int jresult ;
13136   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13137   Dali::Matrix *arg2 = 0 ;
13138   bool result;
13139
13140   arg1 = (Dali::Matrix *)jarg1;
13141   arg2 = (Dali::Matrix *)jarg2;
13142   if (!arg2) {
13143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13144     return 0;
13145   }
13146   {
13147     try {
13148       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13149     } catch (std::out_of_range& e) {
13150       {
13151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13152       };
13153     } catch (std::exception& e) {
13154       {
13155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13156       };
13157     } catch (Dali::DaliException e) {
13158       {
13159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13160       };
13161     } catch (...) {
13162       {
13163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13164       };
13165     }
13166   }
13167
13168   jresult = result;
13169   return jresult;
13170 }
13171
13172
13173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13174   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13175   Dali::Vector3 *arg2 = 0 ;
13176   Dali::Quaternion *arg3 = 0 ;
13177   Dali::Vector3 *arg4 = 0 ;
13178
13179   arg1 = (Dali::Matrix *)jarg1;
13180   arg2 = (Dali::Vector3 *)jarg2;
13181   if (!arg2) {
13182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13183     return ;
13184   }
13185   arg3 = (Dali::Quaternion *)jarg3;
13186   if (!arg3) {
13187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13188     return ;
13189   }
13190   arg4 = (Dali::Vector3 *)jarg4;
13191   if (!arg4) {
13192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13193     return ;
13194   }
13195   {
13196     try {
13197       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13198     } catch (std::out_of_range& e) {
13199       {
13200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13201       };
13202     } catch (std::exception& e) {
13203       {
13204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13205       };
13206     } catch (Dali::DaliException e) {
13207       {
13208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13209       };
13210     } catch (...) {
13211       {
13212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13213       };
13214     }
13215   }
13216
13217 }
13218
13219
13220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13221   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13222   Dali::Vector3 *arg2 = 0 ;
13223   Dali::Quaternion *arg3 = 0 ;
13224   Dali::Vector3 *arg4 = 0 ;
13225
13226   arg1 = (Dali::Matrix *)jarg1;
13227   arg2 = (Dali::Vector3 *)jarg2;
13228   if (!arg2) {
13229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13230     return ;
13231   }
13232   arg3 = (Dali::Quaternion *)jarg3;
13233   if (!arg3) {
13234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13235     return ;
13236   }
13237   arg4 = (Dali::Vector3 *)jarg4;
13238   if (!arg4) {
13239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13240     return ;
13241   }
13242   {
13243     try {
13244       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13245     } catch (std::out_of_range& e) {
13246       {
13247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13248       };
13249     } catch (std::exception& e) {
13250       {
13251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13252       };
13253     } catch (Dali::DaliException e) {
13254       {
13255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13256       };
13257     } catch (...) {
13258       {
13259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13260       };
13261     }
13262   }
13263
13264 }
13265
13266
13267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13268   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13269   Dali::Vector3 *arg2 = 0 ;
13270   Dali::Vector3 *arg3 = 0 ;
13271   Dali::Vector3 *arg4 = 0 ;
13272   Dali::Vector3 *arg5 = 0 ;
13273
13274   arg1 = (Dali::Matrix *)jarg1;
13275   arg2 = (Dali::Vector3 *)jarg2;
13276   if (!arg2) {
13277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13278     return ;
13279   }
13280   arg3 = (Dali::Vector3 *)jarg3;
13281   if (!arg3) {
13282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13283     return ;
13284   }
13285   arg4 = (Dali::Vector3 *)jarg4;
13286   if (!arg4) {
13287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13288     return ;
13289   }
13290   arg5 = (Dali::Vector3 *)jarg5;
13291   if (!arg5) {
13292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13293     return ;
13294   }
13295   {
13296     try {
13297       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13298     } catch (std::out_of_range& e) {
13299       {
13300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13301       };
13302     } catch (std::exception& e) {
13303       {
13304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13305       };
13306     } catch (Dali::DaliException e) {
13307       {
13308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13309       };
13310     } catch (...) {
13311       {
13312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13313       };
13314     }
13315   }
13316
13317 }
13318
13319
13320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13321   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13322   Dali::Vector3 *arg2 = 0 ;
13323   Dali::Quaternion *arg3 = 0 ;
13324   Dali::Vector3 *arg4 = 0 ;
13325
13326   arg1 = (Dali::Matrix *)jarg1;
13327   arg2 = (Dali::Vector3 *)jarg2;
13328   if (!arg2) {
13329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13330     return ;
13331   }
13332   arg3 = (Dali::Quaternion *)jarg3;
13333   if (!arg3) {
13334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13335     return ;
13336   }
13337   arg4 = (Dali::Vector3 *)jarg4;
13338   if (!arg4) {
13339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13340     return ;
13341   }
13342   {
13343     try {
13344       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13345     } catch (std::out_of_range& e) {
13346       {
13347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13348       };
13349     } catch (std::exception& e) {
13350       {
13351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13352       };
13353     } catch (Dali::DaliException e) {
13354       {
13355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13356       };
13357     } catch (...) {
13358       {
13359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13360       };
13361     }
13362   }
13363
13364 }
13365
13366
13367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13368   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13369
13370   arg1 = (Dali::Matrix *)jarg1;
13371   {
13372     try {
13373       delete arg1;
13374     } catch (std::out_of_range& e) {
13375       {
13376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13377       };
13378     } catch (std::exception& e) {
13379       {
13380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13381       };
13382     } catch (Dali::DaliException e) {
13383       {
13384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13385       };
13386     } catch (...) {
13387       {
13388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13389       };
13390     }
13391   }
13392
13393 }
13394
13395
13396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13397   void * jresult ;
13398   Dali::Matrix3 *result = 0 ;
13399
13400   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13401   jresult = (void *)result;
13402   return jresult;
13403 }
13404
13405
13406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13407   void * jresult ;
13408   Dali::Matrix3 *result = 0 ;
13409
13410   {
13411     try {
13412       result = (Dali::Matrix3 *)new Dali::Matrix3();
13413     } catch (std::out_of_range& e) {
13414       {
13415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13416       };
13417     } catch (std::exception& e) {
13418       {
13419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13420       };
13421     } catch (Dali::DaliException e) {
13422       {
13423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13424       };
13425     } catch (...) {
13426       {
13427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13428       };
13429     }
13430   }
13431
13432   jresult = (void *)result;
13433   return jresult;
13434 }
13435
13436
13437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13438   void * jresult ;
13439   Dali::Matrix3 *arg1 = 0 ;
13440   Dali::Matrix3 *result = 0 ;
13441
13442   arg1 = (Dali::Matrix3 *)jarg1;
13443   if (!arg1) {
13444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13445     return 0;
13446   }
13447   {
13448     try {
13449       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13450     } catch (std::out_of_range& e) {
13451       {
13452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13453       };
13454     } catch (std::exception& e) {
13455       {
13456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13457       };
13458     } catch (Dali::DaliException e) {
13459       {
13460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13461       };
13462     } catch (...) {
13463       {
13464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13465       };
13466     }
13467   }
13468
13469   jresult = (void *)result;
13470   return jresult;
13471 }
13472
13473
13474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13475   void * jresult ;
13476   Dali::Matrix *arg1 = 0 ;
13477   Dali::Matrix3 *result = 0 ;
13478
13479   arg1 = (Dali::Matrix *)jarg1;
13480   if (!arg1) {
13481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13482     return 0;
13483   }
13484   {
13485     try {
13486       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13487     } catch (std::out_of_range& e) {
13488       {
13489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13490       };
13491     } catch (std::exception& e) {
13492       {
13493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13494       };
13495     } catch (Dali::DaliException e) {
13496       {
13497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13498       };
13499     } catch (...) {
13500       {
13501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13502       };
13503     }
13504   }
13505
13506   jresult = (void *)result;
13507   return jresult;
13508 }
13509
13510
13511 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) {
13512   void * jresult ;
13513   float arg1 ;
13514   float arg2 ;
13515   float arg3 ;
13516   float arg4 ;
13517   float arg5 ;
13518   float arg6 ;
13519   float arg7 ;
13520   float arg8 ;
13521   float arg9 ;
13522   Dali::Matrix3 *result = 0 ;
13523
13524   arg1 = (float)jarg1;
13525   arg2 = (float)jarg2;
13526   arg3 = (float)jarg3;
13527   arg4 = (float)jarg4;
13528   arg5 = (float)jarg5;
13529   arg6 = (float)jarg6;
13530   arg7 = (float)jarg7;
13531   arg8 = (float)jarg8;
13532   arg9 = (float)jarg9;
13533   {
13534     try {
13535       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13536     } catch (std::out_of_range& e) {
13537       {
13538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13539       };
13540     } catch (std::exception& e) {
13541       {
13542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13543       };
13544     } catch (Dali::DaliException e) {
13545       {
13546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13547       };
13548     } catch (...) {
13549       {
13550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13551       };
13552     }
13553   }
13554
13555   jresult = (void *)result;
13556   return jresult;
13557 }
13558
13559
13560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13561   void * jresult ;
13562   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13563   Dali::Matrix3 *arg2 = 0 ;
13564   Dali::Matrix3 *result = 0 ;
13565
13566   arg1 = (Dali::Matrix3 *)jarg1;
13567   arg2 = (Dali::Matrix3 *)jarg2;
13568   if (!arg2) {
13569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13570     return 0;
13571   }
13572   {
13573     try {
13574       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13575     } catch (std::out_of_range& e) {
13576       {
13577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13578       };
13579     } catch (std::exception& e) {
13580       {
13581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13582       };
13583     } catch (Dali::DaliException e) {
13584       {
13585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13586       };
13587     } catch (...) {
13588       {
13589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13590       };
13591     }
13592   }
13593
13594   jresult = (void *)result;
13595   return jresult;
13596 }
13597
13598
13599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13600   void * jresult ;
13601   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13602   Dali::Matrix *arg2 = 0 ;
13603   Dali::Matrix3 *result = 0 ;
13604
13605   arg1 = (Dali::Matrix3 *)jarg1;
13606   arg2 = (Dali::Matrix *)jarg2;
13607   if (!arg2) {
13608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13609     return 0;
13610   }
13611   {
13612     try {
13613       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13614     } catch (std::out_of_range& e) {
13615       {
13616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13617       };
13618     } catch (std::exception& e) {
13619       {
13620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13621       };
13622     } catch (Dali::DaliException e) {
13623       {
13624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13625       };
13626     } catch (...) {
13627       {
13628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13629       };
13630     }
13631   }
13632
13633   jresult = (void *)result;
13634   return jresult;
13635 }
13636
13637
13638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13639   unsigned int jresult ;
13640   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13641   Dali::Matrix3 *arg2 = 0 ;
13642   bool result;
13643
13644   arg1 = (Dali::Matrix3 *)jarg1;
13645   arg2 = (Dali::Matrix3 *)jarg2;
13646   if (!arg2) {
13647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13648     return 0;
13649   }
13650   {
13651     try {
13652       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13653     } catch (std::out_of_range& e) {
13654       {
13655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13656       };
13657     } catch (std::exception& e) {
13658       {
13659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13660       };
13661     } catch (Dali::DaliException e) {
13662       {
13663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13664       };
13665     } catch (...) {
13666       {
13667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13668       };
13669     }
13670   }
13671
13672   jresult = result;
13673   return jresult;
13674 }
13675
13676
13677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13678   unsigned int jresult ;
13679   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13680   Dali::Matrix3 *arg2 = 0 ;
13681   bool result;
13682
13683   arg1 = (Dali::Matrix3 *)jarg1;
13684   arg2 = (Dali::Matrix3 *)jarg2;
13685   if (!arg2) {
13686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13687     return 0;
13688   }
13689   {
13690     try {
13691       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13692     } catch (std::out_of_range& e) {
13693       {
13694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13695       };
13696     } catch (std::exception& e) {
13697       {
13698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13699       };
13700     } catch (Dali::DaliException e) {
13701       {
13702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13703       };
13704     } catch (...) {
13705       {
13706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13707       };
13708     }
13709   }
13710
13711   jresult = result;
13712   return jresult;
13713 }
13714
13715
13716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13717   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13718
13719   arg1 = (Dali::Matrix3 *)jarg1;
13720   {
13721     try {
13722       delete arg1;
13723     } catch (std::out_of_range& e) {
13724       {
13725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13726       };
13727     } catch (std::exception& e) {
13728       {
13729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13730       };
13731     } catch (Dali::DaliException e) {
13732       {
13733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13734       };
13735     } catch (...) {
13736       {
13737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13738       };
13739     }
13740   }
13741
13742 }
13743
13744
13745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13746   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13747
13748   arg1 = (Dali::Matrix3 *)jarg1;
13749   {
13750     try {
13751       (arg1)->SetIdentity();
13752     } catch (std::out_of_range& e) {
13753       {
13754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13755       };
13756     } catch (std::exception& e) {
13757       {
13758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13759       };
13760     } catch (Dali::DaliException e) {
13761       {
13762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13763       };
13764     } catch (...) {
13765       {
13766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13767       };
13768     }
13769   }
13770
13771 }
13772
13773
13774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13775   void * jresult ;
13776   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13777   float *result = 0 ;
13778
13779   arg1 = (Dali::Matrix3 *)jarg1;
13780   {
13781     try {
13782       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13783     } catch (std::out_of_range& e) {
13784       {
13785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13786       };
13787     } catch (std::exception& e) {
13788       {
13789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13790       };
13791     } catch (Dali::DaliException e) {
13792       {
13793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13794       };
13795     } catch (...) {
13796       {
13797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13798       };
13799     }
13800   }
13801
13802   jresult = (void *)result;
13803   return jresult;
13804 }
13805
13806
13807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13808   unsigned int jresult ;
13809   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13810   bool result;
13811
13812   arg1 = (Dali::Matrix3 *)jarg1;
13813   {
13814     try {
13815       result = (bool)(arg1)->Invert();
13816     } catch (std::out_of_range& e) {
13817       {
13818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13819       };
13820     } catch (std::exception& e) {
13821       {
13822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13823       };
13824     } catch (Dali::DaliException e) {
13825       {
13826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13827       };
13828     } catch (...) {
13829       {
13830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13831       };
13832     }
13833   }
13834
13835   jresult = result;
13836   return jresult;
13837 }
13838
13839
13840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13841   unsigned int jresult ;
13842   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13843   bool result;
13844
13845   arg1 = (Dali::Matrix3 *)jarg1;
13846   {
13847     try {
13848       result = (bool)(arg1)->Transpose();
13849     } catch (std::out_of_range& e) {
13850       {
13851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13852       };
13853     } catch (std::exception& e) {
13854       {
13855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13856       };
13857     } catch (Dali::DaliException e) {
13858       {
13859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13860       };
13861     } catch (...) {
13862       {
13863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13864       };
13865     }
13866   }
13867
13868   jresult = result;
13869   return jresult;
13870 }
13871
13872
13873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13874   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13875   float arg2 ;
13876
13877   arg1 = (Dali::Matrix3 *)jarg1;
13878   arg2 = (float)jarg2;
13879   {
13880     try {
13881       (arg1)->Scale(arg2);
13882     } catch (std::out_of_range& e) {
13883       {
13884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13885       };
13886     } catch (std::exception& e) {
13887       {
13888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13889       };
13890     } catch (Dali::DaliException e) {
13891       {
13892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13893       };
13894     } catch (...) {
13895       {
13896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13897       };
13898     }
13899   }
13900
13901 }
13902
13903
13904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13905   float jresult ;
13906   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13907   float result;
13908
13909   arg1 = (Dali::Matrix3 *)jarg1;
13910   {
13911     try {
13912       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13913     } catch (std::out_of_range& e) {
13914       {
13915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13916       };
13917     } catch (std::exception& e) {
13918       {
13919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13920       };
13921     } catch (Dali::DaliException e) {
13922       {
13923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13924       };
13925     } catch (...) {
13926       {
13927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13928       };
13929     }
13930   }
13931
13932   jresult = result;
13933   return jresult;
13934 }
13935
13936
13937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13938   unsigned int jresult ;
13939   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13940   bool result;
13941
13942   arg1 = (Dali::Matrix3 *)jarg1;
13943   {
13944     try {
13945       result = (bool)(arg1)->ScaledInverseTranspose();
13946     } catch (std::out_of_range& e) {
13947       {
13948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13949       };
13950     } catch (std::exception& e) {
13951       {
13952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13953       };
13954     } catch (Dali::DaliException e) {
13955       {
13956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13957       };
13958     } catch (...) {
13959       {
13960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13961       };
13962     }
13963   }
13964
13965   jresult = result;
13966   return jresult;
13967 }
13968
13969
13970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13971   Dali::Matrix3 *arg1 = 0 ;
13972   Dali::Matrix3 *arg2 = 0 ;
13973   Dali::Matrix3 *arg3 = 0 ;
13974
13975   arg1 = (Dali::Matrix3 *)jarg1;
13976   if (!arg1) {
13977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13978     return ;
13979   }
13980   arg2 = (Dali::Matrix3 *)jarg2;
13981   if (!arg2) {
13982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13983     return ;
13984   }
13985   arg3 = (Dali::Matrix3 *)jarg3;
13986   if (!arg3) {
13987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13988     return ;
13989   }
13990   {
13991     try {
13992       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13993     } catch (std::out_of_range& e) {
13994       {
13995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13996       };
13997     } catch (std::exception& e) {
13998       {
13999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14000       };
14001     } catch (Dali::DaliException e) {
14002       {
14003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14004       };
14005     } catch (...) {
14006       {
14007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14008       };
14009     }
14010   }
14011
14012 }
14013
14014
14015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14016   float jresult ;
14017   float arg1 ;
14018   float arg2 ;
14019   float result;
14020
14021   arg1 = (float)jarg1;
14022   arg2 = (float)jarg2;
14023   {
14024     try {
14025       result = (float)Dali::Random::Range(arg1,arg2);
14026     } catch (std::out_of_range& e) {
14027       {
14028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14029       };
14030     } catch (std::exception& e) {
14031       {
14032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14033       };
14034     } catch (Dali::DaliException e) {
14035       {
14036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14037       };
14038     } catch (...) {
14039       {
14040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14041       };
14042     }
14043   }
14044
14045   jresult = result;
14046   return jresult;
14047 }
14048
14049
14050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14051   void * jresult ;
14052   Dali::Vector4 result;
14053
14054   {
14055     try {
14056       result = Dali::Random::Axis();
14057     } catch (std::out_of_range& e) {
14058       {
14059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14060       };
14061     } catch (std::exception& e) {
14062       {
14063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14064       };
14065     } catch (Dali::DaliException e) {
14066       {
14067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14068       };
14069     } catch (...) {
14070       {
14071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14072       };
14073     }
14074   }
14075
14076   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14077   return jresult;
14078 }
14079
14080
14081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14082   void * jresult ;
14083   Dali::AngleAxis *result = 0 ;
14084
14085   {
14086     try {
14087       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14088     } catch (std::out_of_range& e) {
14089       {
14090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14091       };
14092     } catch (std::exception& e) {
14093       {
14094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14095       };
14096     } catch (Dali::DaliException e) {
14097       {
14098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14099       };
14100     } catch (...) {
14101       {
14102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14103       };
14104     }
14105   }
14106
14107   jresult = (void *)result;
14108   return jresult;
14109 }
14110
14111
14112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14113   void * jresult ;
14114   Dali::Radian arg1 ;
14115   Dali::Vector3 *arg2 = 0 ;
14116   Dali::Radian *argp1 ;
14117   Dali::AngleAxis *result = 0 ;
14118
14119   argp1 = (Dali::Radian *)jarg1;
14120   if (!argp1) {
14121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14122     return 0;
14123   }
14124   arg1 = *argp1;
14125   arg2 = (Dali::Vector3 *)jarg2;
14126   if (!arg2) {
14127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14128     return 0;
14129   }
14130   {
14131     try {
14132       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14133     } catch (std::out_of_range& e) {
14134       {
14135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14136       };
14137     } catch (std::exception& e) {
14138       {
14139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14140       };
14141     } catch (Dali::DaliException e) {
14142       {
14143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14144       };
14145     } catch (...) {
14146       {
14147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14148       };
14149     }
14150   }
14151
14152   jresult = (void *)result;
14153   return jresult;
14154 }
14155
14156
14157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14158   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14159   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14160
14161   arg1 = (Dali::AngleAxis *)jarg1;
14162   arg2 = (Dali::Radian *)jarg2;
14163   if (arg1) (arg1)->angle = *arg2;
14164 }
14165
14166
14167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14168   void * jresult ;
14169   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14170   Dali::Radian *result = 0 ;
14171
14172   arg1 = (Dali::AngleAxis *)jarg1;
14173   result = (Dali::Radian *)& ((arg1)->angle);
14174   jresult = (void *)result;
14175   return jresult;
14176 }
14177
14178
14179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14180   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14181   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14182
14183   arg1 = (Dali::AngleAxis *)jarg1;
14184   arg2 = (Dali::Vector3 *)jarg2;
14185   if (arg1) (arg1)->axis = *arg2;
14186 }
14187
14188
14189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14190   void * jresult ;
14191   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14192   Dali::Vector3 *result = 0 ;
14193
14194   arg1 = (Dali::AngleAxis *)jarg1;
14195   result = (Dali::Vector3 *)& ((arg1)->axis);
14196   jresult = (void *)result;
14197   return jresult;
14198 }
14199
14200
14201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14202   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14203
14204   arg1 = (Dali::AngleAxis *)jarg1;
14205   {
14206     try {
14207       delete arg1;
14208     } catch (std::out_of_range& e) {
14209       {
14210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14211       };
14212     } catch (std::exception& e) {
14213       {
14214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14215       };
14216     } catch (Dali::DaliException e) {
14217       {
14218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14219       };
14220     } catch (...) {
14221       {
14222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14223       };
14224     }
14225   }
14226
14227 }
14228
14229
14230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14231   unsigned int jresult ;
14232   Dali::AngleAxis *arg1 = 0 ;
14233   Dali::AngleAxis *arg2 = 0 ;
14234   bool result;
14235
14236   arg1 = (Dali::AngleAxis *)jarg1;
14237   if (!arg1) {
14238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14239     return 0;
14240   }
14241   arg2 = (Dali::AngleAxis *)jarg2;
14242   if (!arg2) {
14243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14244     return 0;
14245   }
14246   {
14247     try {
14248       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14249     } catch (std::out_of_range& e) {
14250       {
14251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14252       };
14253     } catch (std::exception& e) {
14254       {
14255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14256       };
14257     } catch (Dali::DaliException e) {
14258       {
14259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14260       };
14261     } catch (...) {
14262       {
14263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14264       };
14265     }
14266   }
14267
14268   jresult = result;
14269   return jresult;
14270 }
14271
14272
14273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14274   unsigned int jresult ;
14275   unsigned int arg1 ;
14276   unsigned int result;
14277
14278   arg1 = (unsigned int)jarg1;
14279   {
14280     try {
14281       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14282     } catch (std::out_of_range& e) {
14283       {
14284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14285       };
14286     } catch (std::exception& e) {
14287       {
14288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14289       };
14290     } catch (Dali::DaliException e) {
14291       {
14292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14293       };
14294     } catch (...) {
14295       {
14296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14297       };
14298     }
14299   }
14300
14301   jresult = result;
14302   return jresult;
14303 }
14304
14305
14306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14307   unsigned int jresult ;
14308   unsigned int arg1 ;
14309   bool result;
14310
14311   arg1 = (unsigned int)jarg1;
14312   {
14313     try {
14314       result = (bool)Dali::IsPowerOfTwo(arg1);
14315     } catch (std::out_of_range& e) {
14316       {
14317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14318       };
14319     } catch (std::exception& e) {
14320       {
14321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14322       };
14323     } catch (Dali::DaliException e) {
14324       {
14325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14326       };
14327     } catch (...) {
14328       {
14329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14330       };
14331     }
14332   }
14333
14334   jresult = result;
14335   return jresult;
14336 }
14337
14338
14339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14340   float jresult ;
14341   float arg1 ;
14342   float arg2 ;
14343   float result;
14344
14345   arg1 = (float)jarg1;
14346   arg2 = (float)jarg2;
14347   {
14348     try {
14349       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14350     } catch (std::out_of_range& e) {
14351       {
14352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14353       };
14354     } catch (std::exception& e) {
14355       {
14356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14357       };
14358     } catch (Dali::DaliException e) {
14359       {
14360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14361       };
14362     } catch (...) {
14363       {
14364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14365       };
14366     }
14367   }
14368
14369   jresult = result;
14370   return jresult;
14371 }
14372
14373
14374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14375   unsigned int jresult ;
14376   float arg1 ;
14377   bool result;
14378
14379   arg1 = (float)jarg1;
14380   {
14381     try {
14382       result = (bool)Dali::EqualsZero(arg1);
14383     } catch (std::out_of_range& e) {
14384       {
14385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14386       };
14387     } catch (std::exception& e) {
14388       {
14389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14390       };
14391     } catch (Dali::DaliException e) {
14392       {
14393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14394       };
14395     } catch (...) {
14396       {
14397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14398       };
14399     }
14400   }
14401
14402   jresult = result;
14403   return jresult;
14404 }
14405
14406
14407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14408   unsigned int jresult ;
14409   float arg1 ;
14410   float arg2 ;
14411   bool result;
14412
14413   arg1 = (float)jarg1;
14414   arg2 = (float)jarg2;
14415   {
14416     try {
14417       result = (bool)Dali::Equals(arg1,arg2);
14418     } catch (std::out_of_range& e) {
14419       {
14420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14421       };
14422     } catch (std::exception& e) {
14423       {
14424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14425       };
14426     } catch (Dali::DaliException e) {
14427       {
14428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14429       };
14430     } catch (...) {
14431       {
14432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14433       };
14434     }
14435   }
14436
14437   jresult = result;
14438   return jresult;
14439 }
14440
14441
14442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14443   unsigned int jresult ;
14444   float arg1 ;
14445   float arg2 ;
14446   float arg3 ;
14447   bool result;
14448
14449   arg1 = (float)jarg1;
14450   arg2 = (float)jarg2;
14451   arg3 = (float)jarg3;
14452   {
14453     try {
14454       result = (bool)Dali::Equals(arg1,arg2,arg3);
14455     } catch (std::out_of_range& e) {
14456       {
14457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14458       };
14459     } catch (std::exception& e) {
14460       {
14461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14462       };
14463     } catch (Dali::DaliException e) {
14464       {
14465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14466       };
14467     } catch (...) {
14468       {
14469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14470       };
14471     }
14472   }
14473
14474   jresult = result;
14475   return jresult;
14476 }
14477
14478
14479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14480   float jresult ;
14481   float arg1 ;
14482   int arg2 ;
14483   float result;
14484
14485   arg1 = (float)jarg1;
14486   arg2 = (int)jarg2;
14487   {
14488     try {
14489       result = (float)Dali::Round(arg1,arg2);
14490     } catch (std::out_of_range& e) {
14491       {
14492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14493       };
14494     } catch (std::exception& e) {
14495       {
14496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14497       };
14498     } catch (Dali::DaliException e) {
14499       {
14500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14501       };
14502     } catch (...) {
14503       {
14504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14505       };
14506     }
14507   }
14508
14509   jresult = result;
14510   return jresult;
14511 }
14512
14513
14514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14515   float jresult ;
14516   float arg1 ;
14517   float arg2 ;
14518   float arg3 ;
14519   float result;
14520
14521   arg1 = (float)jarg1;
14522   arg2 = (float)jarg2;
14523   arg3 = (float)jarg3;
14524   {
14525     try {
14526       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14527     } catch (std::out_of_range& e) {
14528       {
14529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14530       };
14531     } catch (std::exception& e) {
14532       {
14533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14534       };
14535     } catch (Dali::DaliException e) {
14536       {
14537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14538       };
14539     } catch (...) {
14540       {
14541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14542       };
14543     }
14544   }
14545
14546   jresult = result;
14547   return jresult;
14548 }
14549
14550
14551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14552   float jresult ;
14553   float arg1 ;
14554   float arg2 ;
14555   float arg3 ;
14556   float arg4 ;
14557   float result;
14558
14559   arg1 = (float)jarg1;
14560   arg2 = (float)jarg2;
14561   arg3 = (float)jarg3;
14562   arg4 = (float)jarg4;
14563   {
14564     try {
14565       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14566     } catch (std::out_of_range& e) {
14567       {
14568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14569       };
14570     } catch (std::exception& e) {
14571       {
14572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14573       };
14574     } catch (Dali::DaliException e) {
14575       {
14576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14577       };
14578     } catch (...) {
14579       {
14580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14581       };
14582     }
14583   }
14584
14585   jresult = result;
14586   return jresult;
14587 }
14588
14589
14590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14591   int jresult ;
14592   int result;
14593
14594   result = (int)(int)Dali::Property::INVALID_INDEX;
14595   jresult = result;
14596   return jresult;
14597 }
14598
14599
14600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14601   int jresult ;
14602   int result;
14603
14604   result = (int)(int)Dali::Property::INVALID_KEY;
14605   jresult = result;
14606   return jresult;
14607 }
14608
14609
14610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14611   int jresult ;
14612   int result;
14613
14614   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14615   jresult = result;
14616   return jresult;
14617 }
14618
14619
14620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14621   void * jresult ;
14622   Dali::Handle *arg1 = 0 ;
14623   Dali::Property::Index arg2 ;
14624   Dali::Property *result = 0 ;
14625
14626   arg1 = (Dali::Handle *)jarg1;
14627   if (!arg1) {
14628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14629     return 0;
14630   }
14631   arg2 = (Dali::Property::Index)jarg2;
14632   {
14633     try {
14634       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14635     } catch (std::out_of_range& e) {
14636       {
14637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14638       };
14639     } catch (std::exception& e) {
14640       {
14641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14642       };
14643     } catch (Dali::DaliException e) {
14644       {
14645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14646       };
14647     } catch (...) {
14648       {
14649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14650       };
14651     }
14652   }
14653
14654   jresult = (void *)result;
14655   return jresult;
14656 }
14657
14658
14659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14660   void * jresult ;
14661   Dali::Handle *arg1 = 0 ;
14662   Dali::Property::Index arg2 ;
14663   int arg3 ;
14664   Dali::Property *result = 0 ;
14665
14666   arg1 = (Dali::Handle *)jarg1;
14667   if (!arg1) {
14668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14669     return 0;
14670   }
14671   arg2 = (Dali::Property::Index)jarg2;
14672   arg3 = (int)jarg3;
14673   {
14674     try {
14675       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14676     } catch (std::out_of_range& e) {
14677       {
14678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14679       };
14680     } catch (std::exception& e) {
14681       {
14682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14683       };
14684     } catch (Dali::DaliException e) {
14685       {
14686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14687       };
14688     } catch (...) {
14689       {
14690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14691       };
14692     }
14693   }
14694
14695   jresult = (void *)result;
14696   return jresult;
14697 }
14698
14699
14700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14701   void * jresult ;
14702   Dali::Handle *arg1 = 0 ;
14703   std::string *arg2 = 0 ;
14704   Dali::Property *result = 0 ;
14705
14706   arg1 = (Dali::Handle *)jarg1;
14707   if (!arg1) {
14708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14709     return 0;
14710   }
14711   if (!jarg2) {
14712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14713     return 0;
14714   }
14715   std::string arg2_str(jarg2);
14716   arg2 = &arg2_str;
14717   {
14718     try {
14719       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14720     } catch (std::out_of_range& e) {
14721       {
14722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14723       };
14724     } catch (std::exception& e) {
14725       {
14726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14727       };
14728     } catch (Dali::DaliException e) {
14729       {
14730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14731       };
14732     } catch (...) {
14733       {
14734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14735       };
14736     }
14737   }
14738
14739   jresult = (void *)result;
14740
14741   //argout typemap for const std::string&
14742
14743   return jresult;
14744 }
14745
14746
14747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14748   void * jresult ;
14749   Dali::Handle *arg1 = 0 ;
14750   std::string *arg2 = 0 ;
14751   int arg3 ;
14752   Dali::Property *result = 0 ;
14753
14754   arg1 = (Dali::Handle *)jarg1;
14755   if (!arg1) {
14756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14757     return 0;
14758   }
14759   if (!jarg2) {
14760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14761     return 0;
14762   }
14763   std::string arg2_str(jarg2);
14764   arg2 = &arg2_str;
14765   arg3 = (int)jarg3;
14766   {
14767     try {
14768       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14769     } catch (std::out_of_range& e) {
14770       {
14771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (std::exception& e) {
14774       {
14775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14776       };
14777     } catch (Dali::DaliException e) {
14778       {
14779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14780       };
14781     } catch (...) {
14782       {
14783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14784       };
14785     }
14786   }
14787
14788   jresult = (void *)result;
14789
14790   //argout typemap for const std::string&
14791
14792   return jresult;
14793 }
14794
14795
14796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14797   Dali::Property *arg1 = (Dali::Property *) 0 ;
14798
14799   arg1 = (Dali::Property *)jarg1;
14800   {
14801     try {
14802       delete arg1;
14803     } catch (std::out_of_range& e) {
14804       {
14805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14806       };
14807     } catch (std::exception& e) {
14808       {
14809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14810       };
14811     } catch (Dali::DaliException e) {
14812       {
14813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14814       };
14815     } catch (...) {
14816       {
14817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14818       };
14819     }
14820   }
14821
14822 }
14823
14824
14825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14826   Dali::Property *arg1 = (Dali::Property *) 0 ;
14827   Dali::Handle *arg2 = 0 ;
14828
14829   arg1 = (Dali::Property *)jarg1;
14830   arg2 = (Dali::Handle *)jarg2;
14831   if (!arg2) {
14832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14833     return ;
14834   }
14835   if (arg1) (arg1)->object = *arg2;
14836 }
14837
14838
14839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14840   void * jresult ;
14841   Dali::Property *arg1 = (Dali::Property *) 0 ;
14842   Dali::Handle *result = 0 ;
14843
14844   arg1 = (Dali::Property *)jarg1;
14845   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14846   jresult = (void *)result;
14847   return jresult;
14848 }
14849
14850
14851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14852   Dali::Property *arg1 = (Dali::Property *) 0 ;
14853   Dali::Property::Index arg2 ;
14854
14855   arg1 = (Dali::Property *)jarg1;
14856   arg2 = (Dali::Property::Index)jarg2;
14857   if (arg1) (arg1)->propertyIndex = arg2;
14858 }
14859
14860
14861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14862   int jresult ;
14863   Dali::Property *arg1 = (Dali::Property *) 0 ;
14864   Dali::Property::Index result;
14865
14866   arg1 = (Dali::Property *)jarg1;
14867   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14868   jresult = result;
14869   return jresult;
14870 }
14871
14872
14873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14874   Dali::Property *arg1 = (Dali::Property *) 0 ;
14875   int arg2 ;
14876
14877   arg1 = (Dali::Property *)jarg1;
14878   arg2 = (int)jarg2;
14879   if (arg1) (arg1)->componentIndex = arg2;
14880 }
14881
14882
14883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14884   int jresult ;
14885   Dali::Property *arg1 = (Dali::Property *) 0 ;
14886   int result;
14887
14888   arg1 = (Dali::Property *)jarg1;
14889   result = (int) ((arg1)->componentIndex);
14890   jresult = result;
14891   return jresult;
14892 }
14893
14894
14895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14896   void * jresult ;
14897   Dali::Property::Array *result = 0 ;
14898
14899   {
14900     try {
14901       result = (Dali::Property::Array *)new Dali::Property::Array();
14902     } catch (std::out_of_range& e) {
14903       {
14904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14905       };
14906     } catch (std::exception& e) {
14907       {
14908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14909       };
14910     } catch (Dali::DaliException e) {
14911       {
14912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14913       };
14914     } catch (...) {
14915       {
14916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14917       };
14918     }
14919   }
14920
14921   jresult = (void *)result;
14922   return jresult;
14923 }
14924
14925
14926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14927   void * jresult ;
14928   Dali::Property::Array *arg1 = 0 ;
14929   Dali::Property::Array *result = 0 ;
14930
14931   arg1 = (Dali::Property::Array *)jarg1;
14932   if (!arg1) {
14933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14934     return 0;
14935   }
14936   {
14937     try {
14938       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14939     } catch (std::out_of_range& e) {
14940       {
14941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14942       };
14943     } catch (std::exception& e) {
14944       {
14945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14946       };
14947     } catch (Dali::DaliException e) {
14948       {
14949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14950       };
14951     } catch (...) {
14952       {
14953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14954       };
14955     }
14956   }
14957
14958   jresult = (void *)result;
14959   return jresult;
14960 }
14961
14962
14963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14964   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14965
14966   arg1 = (Dali::Property::Array *)jarg1;
14967   {
14968     try {
14969       delete arg1;
14970     } catch (std::out_of_range& e) {
14971       {
14972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14973       };
14974     } catch (std::exception& e) {
14975       {
14976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14977       };
14978     } catch (Dali::DaliException e) {
14979       {
14980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14981       };
14982     } catch (...) {
14983       {
14984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14985       };
14986     }
14987   }
14988
14989 }
14990
14991
14992 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14993   unsigned long jresult ;
14994   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14995   Dali::Property::Array::SizeType result;
14996
14997   arg1 = (Dali::Property::Array *)jarg1;
14998   {
14999     try {
15000       result = ((Dali::Property::Array const *)arg1)->Size();
15001     } catch (std::out_of_range& e) {
15002       {
15003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15004       };
15005     } catch (std::exception& e) {
15006       {
15007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15008       };
15009     } catch (Dali::DaliException e) {
15010       {
15011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15012       };
15013     } catch (...) {
15014       {
15015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15016       };
15017     }
15018   }
15019
15020   jresult = (unsigned long)result;
15021   return jresult;
15022 }
15023
15024
15025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15026   unsigned long jresult ;
15027   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15028   Dali::Property::Array::SizeType result;
15029
15030   arg1 = (Dali::Property::Array *)jarg1;
15031   {
15032     try {
15033       result = ((Dali::Property::Array const *)arg1)->Count();
15034     } catch (std::out_of_range& e) {
15035       {
15036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15037       };
15038     } catch (std::exception& e) {
15039       {
15040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15041       };
15042     } catch (Dali::DaliException e) {
15043       {
15044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15045       };
15046     } catch (...) {
15047       {
15048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15049       };
15050     }
15051   }
15052
15053   jresult = (unsigned long)result;
15054   return jresult;
15055 }
15056
15057
15058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15059   unsigned int jresult ;
15060   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15061   bool result;
15062
15063   arg1 = (Dali::Property::Array *)jarg1;
15064   {
15065     try {
15066       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15067     } catch (std::out_of_range& e) {
15068       {
15069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15070       };
15071     } catch (std::exception& e) {
15072       {
15073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15074       };
15075     } catch (Dali::DaliException e) {
15076       {
15077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15078       };
15079     } catch (...) {
15080       {
15081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15082       };
15083     }
15084   }
15085
15086   jresult = result;
15087   return jresult;
15088 }
15089
15090
15091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15092   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15093
15094   arg1 = (Dali::Property::Array *)jarg1;
15095   {
15096     try {
15097       (arg1)->Clear();
15098     } catch (std::out_of_range& e) {
15099       {
15100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15101       };
15102     } catch (std::exception& e) {
15103       {
15104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15105       };
15106     } catch (Dali::DaliException e) {
15107       {
15108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15109       };
15110     } catch (...) {
15111       {
15112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15113       };
15114     }
15115   }
15116
15117 }
15118
15119
15120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15121   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15122   Dali::Property::Array::SizeType arg2 ;
15123
15124   arg1 = (Dali::Property::Array *)jarg1;
15125   arg2 = (Dali::Property::Array::SizeType)jarg2;
15126   {
15127     try {
15128       (arg1)->Reserve(arg2);
15129     } catch (std::out_of_range& e) {
15130       {
15131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15132       };
15133     } catch (std::exception& e) {
15134       {
15135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15136       };
15137     } catch (Dali::DaliException e) {
15138       {
15139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15140       };
15141     } catch (...) {
15142       {
15143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15144       };
15145     }
15146   }
15147
15148 }
15149
15150
15151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15152   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15153   Dali::Property::Array::SizeType arg2 ;
15154
15155   arg1 = (Dali::Property::Array *)jarg1;
15156   arg2 = (Dali::Property::Array::SizeType)jarg2;
15157   {
15158     try {
15159       (arg1)->Resize(arg2);
15160     } catch (std::out_of_range& e) {
15161       {
15162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15163       };
15164     } catch (std::exception& e) {
15165       {
15166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15167       };
15168     } catch (Dali::DaliException e) {
15169       {
15170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15171       };
15172     } catch (...) {
15173       {
15174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15175       };
15176     }
15177   }
15178
15179 }
15180
15181
15182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15183   unsigned long jresult ;
15184   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15185   Dali::Property::Array::SizeType result;
15186
15187   arg1 = (Dali::Property::Array *)jarg1;
15188   {
15189     try {
15190       result = (arg1)->Capacity();
15191     } catch (std::out_of_range& e) {
15192       {
15193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15194       };
15195     } catch (std::exception& e) {
15196       {
15197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15198       };
15199     } catch (Dali::DaliException e) {
15200       {
15201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15202       };
15203     } catch (...) {
15204       {
15205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15206       };
15207     }
15208   }
15209
15210   jresult = (unsigned long)result;
15211   return jresult;
15212 }
15213
15214
15215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15216   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15217   Dali::Property::Value *arg2 = 0 ;
15218
15219   arg1 = (Dali::Property::Array *)jarg1;
15220   arg2 = (Dali::Property::Value *)jarg2;
15221   if (!arg2) {
15222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15223     return ;
15224   }
15225   {
15226     try {
15227       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15228     } catch (std::out_of_range& e) {
15229       {
15230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15231       };
15232     } catch (std::exception& e) {
15233       {
15234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15235       };
15236     } catch (Dali::DaliException e) {
15237       {
15238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15239       };
15240     } catch (...) {
15241       {
15242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15243       };
15244     }
15245   }
15246
15247 }
15248
15249
15250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15251   void * jresult ;
15252   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15253   Dali::Property::Value *arg2 = 0 ;
15254   Dali::Property::Array *result = 0 ;
15255
15256   arg1 = (Dali::Property::Array *)jarg1;
15257   arg2 = (Dali::Property::Value *)jarg2;
15258   if (!arg2) {
15259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15260     return 0;
15261   }
15262   {
15263     try {
15264       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15265     } catch (std::out_of_range& e) {
15266       {
15267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15268       };
15269     } catch (std::exception& e) {
15270       {
15271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15272       };
15273     } catch (Dali::DaliException e) {
15274       {
15275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15276       };
15277     } catch (...) {
15278       {
15279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15280       };
15281     }
15282   }
15283
15284   jresult = (void *)result;
15285   return jresult;
15286 }
15287
15288
15289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15290   void * jresult ;
15291   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15292   Dali::Property::Array::SizeType arg2 ;
15293   Dali::Property::Value *result = 0 ;
15294
15295   arg1 = (Dali::Property::Array *)jarg1;
15296   arg2 = (Dali::Property::Array::SizeType)jarg2;
15297   {
15298     try {
15299       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15300     } catch (std::out_of_range& e) {
15301       {
15302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15303       };
15304     } catch (std::exception& e) {
15305       {
15306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15307       };
15308     } catch (Dali::DaliException e) {
15309       {
15310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15311       };
15312     } catch (...) {
15313       {
15314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15315       };
15316     }
15317   }
15318
15319   jresult = (void *)result;
15320   return jresult;
15321 }
15322
15323
15324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15325   void * jresult ;
15326   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15327   Dali::Property::Array::SizeType arg2 ;
15328   Dali::Property::Value *result = 0 ;
15329
15330   arg1 = (Dali::Property::Array *)jarg1;
15331   arg2 = (Dali::Property::Array::SizeType)jarg2;
15332   {
15333     try {
15334       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15335     } catch (std::out_of_range& e) {
15336       {
15337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15338       };
15339     } catch (std::exception& e) {
15340       {
15341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15342       };
15343     } catch (Dali::DaliException e) {
15344       {
15345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15346       };
15347     } catch (...) {
15348       {
15349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15350       };
15351     }
15352   }
15353
15354   jresult = (void *)result;
15355   return jresult;
15356 }
15357
15358
15359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15360   void * jresult ;
15361   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15362   Dali::Property::Array *arg2 = 0 ;
15363   Dali::Property::Array *result = 0 ;
15364
15365   arg1 = (Dali::Property::Array *)jarg1;
15366   arg2 = (Dali::Property::Array *)jarg2;
15367   if (!arg2) {
15368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15369     return 0;
15370   }
15371   {
15372     try {
15373       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15374     } catch (std::out_of_range& e) {
15375       {
15376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15377       };
15378     } catch (std::exception& e) {
15379       {
15380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15381       };
15382     } catch (Dali::DaliException e) {
15383       {
15384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15385       };
15386     } catch (...) {
15387       {
15388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15389       };
15390     }
15391   }
15392
15393   jresult = (void *)result;
15394   return jresult;
15395 }
15396
15397
15398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15399   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15400   enum Dali::Property::Key::Type arg2 ;
15401
15402   arg1 = (Dali::Property::Key *)jarg1;
15403   arg2 = (enum Dali::Property::Key::Type)jarg2;
15404   if (arg1) (arg1)->type = arg2;
15405 }
15406
15407
15408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15409   int jresult ;
15410   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15411   enum Dali::Property::Key::Type result;
15412
15413   arg1 = (Dali::Property::Key *)jarg1;
15414   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15415   jresult = (int)result;
15416   return jresult;
15417 }
15418
15419
15420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15421   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15422   Dali::Property::Index arg2 ;
15423
15424   arg1 = (Dali::Property::Key *)jarg1;
15425   arg2 = (Dali::Property::Index)jarg2;
15426   if (arg1) (arg1)->indexKey = arg2;
15427 }
15428
15429
15430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15431   int jresult ;
15432   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15433   Dali::Property::Index result;
15434
15435   arg1 = (Dali::Property::Key *)jarg1;
15436   result = (Dali::Property::Index) ((arg1)->indexKey);
15437   jresult = result;
15438   return jresult;
15439 }
15440
15441
15442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15443   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15444   std::string *arg2 = 0 ;
15445
15446   arg1 = (Dali::Property::Key *)jarg1;
15447   if (!jarg2) {
15448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15449     return ;
15450   }
15451   std::string arg2_str(jarg2);
15452   arg2 = &arg2_str;
15453   if (arg1) (arg1)->stringKey = *arg2;
15454
15455   //argout typemap for const std::string&
15456
15457 }
15458
15459
15460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15461   char * jresult ;
15462   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15463   std::string *result = 0 ;
15464
15465   arg1 = (Dali::Property::Key *)jarg1;
15466   result = (std::string *) & ((arg1)->stringKey);
15467   jresult = SWIG_csharp_string_callback(result->c_str());
15468   return jresult;
15469 }
15470
15471
15472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15473   void * jresult ;
15474   std::string *arg1 = 0 ;
15475   Dali::Property::Key *result = 0 ;
15476
15477   if (!jarg1) {
15478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15479     return 0;
15480   }
15481   std::string arg1_str(jarg1);
15482   arg1 = &arg1_str;
15483   {
15484     try {
15485       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15486     } catch (std::out_of_range& e) {
15487       {
15488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15489       };
15490     } catch (std::exception& e) {
15491       {
15492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15493       };
15494     } catch (Dali::DaliException e) {
15495       {
15496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15497       };
15498     } catch (...) {
15499       {
15500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15501       };
15502     }
15503   }
15504
15505   jresult = (void *)result;
15506
15507   //argout typemap for const std::string&
15508
15509   return jresult;
15510 }
15511
15512
15513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15514   void * jresult ;
15515   Dali::Property::Index arg1 ;
15516   Dali::Property::Key *result = 0 ;
15517
15518   arg1 = (Dali::Property::Index)jarg1;
15519   {
15520     try {
15521       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15522     } catch (std::out_of_range& e) {
15523       {
15524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15525       };
15526     } catch (std::exception& e) {
15527       {
15528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15529       };
15530     } catch (Dali::DaliException e) {
15531       {
15532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15533       };
15534     } catch (...) {
15535       {
15536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15537       };
15538     }
15539   }
15540
15541   jresult = (void *)result;
15542   return jresult;
15543 }
15544
15545
15546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15547   unsigned int jresult ;
15548   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15549   std::string *arg2 = 0 ;
15550   bool result;
15551
15552   arg1 = (Dali::Property::Key *)jarg1;
15553   if (!jarg2) {
15554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15555     return 0;
15556   }
15557   std::string arg2_str(jarg2);
15558   arg2 = &arg2_str;
15559   {
15560     try {
15561       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15562     } catch (std::out_of_range& e) {
15563       {
15564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15565       };
15566     } catch (std::exception& e) {
15567       {
15568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15569       };
15570     } catch (Dali::DaliException e) {
15571       {
15572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15573       };
15574     } catch (...) {
15575       {
15576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15577       };
15578     }
15579   }
15580
15581   jresult = result;
15582
15583   //argout typemap for const std::string&
15584
15585   return jresult;
15586 }
15587
15588
15589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15590   unsigned int jresult ;
15591   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15592   Dali::Property::Index arg2 ;
15593   bool result;
15594
15595   arg1 = (Dali::Property::Key *)jarg1;
15596   arg2 = (Dali::Property::Index)jarg2;
15597   {
15598     try {
15599       result = (bool)(arg1)->operator ==(arg2);
15600     } catch (std::out_of_range& e) {
15601       {
15602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15603       };
15604     } catch (std::exception& e) {
15605       {
15606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15607       };
15608     } catch (Dali::DaliException e) {
15609       {
15610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15611       };
15612     } catch (...) {
15613       {
15614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15615       };
15616     }
15617   }
15618
15619   jresult = result;
15620   return jresult;
15621 }
15622
15623
15624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15625   unsigned int jresult ;
15626   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15627   Dali::Property::Key *arg2 = 0 ;
15628   bool result;
15629
15630   arg1 = (Dali::Property::Key *)jarg1;
15631   arg2 = (Dali::Property::Key *)jarg2;
15632   if (!arg2) {
15633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15634     return 0;
15635   }
15636   {
15637     try {
15638       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15639     } catch (std::out_of_range& e) {
15640       {
15641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15642       };
15643     } catch (std::exception& e) {
15644       {
15645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15646       };
15647     } catch (Dali::DaliException e) {
15648       {
15649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15650       };
15651     } catch (...) {
15652       {
15653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15654       };
15655     }
15656   }
15657
15658   jresult = result;
15659   return jresult;
15660 }
15661
15662
15663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15664   unsigned int jresult ;
15665   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15666   std::string *arg2 = 0 ;
15667   bool result;
15668
15669   arg1 = (Dali::Property::Key *)jarg1;
15670   if (!jarg2) {
15671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15672     return 0;
15673   }
15674   std::string arg2_str(jarg2);
15675   arg2 = &arg2_str;
15676   {
15677     try {
15678       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15679     } catch (std::out_of_range& e) {
15680       {
15681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15682       };
15683     } catch (std::exception& e) {
15684       {
15685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15686       };
15687     } catch (Dali::DaliException e) {
15688       {
15689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15690       };
15691     } catch (...) {
15692       {
15693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15694       };
15695     }
15696   }
15697
15698   jresult = result;
15699
15700   //argout typemap for const std::string&
15701
15702   return jresult;
15703 }
15704
15705
15706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15707   unsigned int jresult ;
15708   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15709   Dali::Property::Index arg2 ;
15710   bool result;
15711
15712   arg1 = (Dali::Property::Key *)jarg1;
15713   arg2 = (Dali::Property::Index)jarg2;
15714   {
15715     try {
15716       result = (bool)(arg1)->operator !=(arg2);
15717     } catch (std::out_of_range& e) {
15718       {
15719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15720       };
15721     } catch (std::exception& e) {
15722       {
15723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15724       };
15725     } catch (Dali::DaliException e) {
15726       {
15727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15728       };
15729     } catch (...) {
15730       {
15731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15732       };
15733     }
15734   }
15735
15736   jresult = result;
15737   return jresult;
15738 }
15739
15740
15741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15742   unsigned int jresult ;
15743   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15744   Dali::Property::Key *arg2 = 0 ;
15745   bool result;
15746
15747   arg1 = (Dali::Property::Key *)jarg1;
15748   arg2 = (Dali::Property::Key *)jarg2;
15749   if (!arg2) {
15750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15751     return 0;
15752   }
15753   {
15754     try {
15755       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15756     } catch (std::out_of_range& e) {
15757       {
15758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15759       };
15760     } catch (std::exception& e) {
15761       {
15762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15763       };
15764     } catch (Dali::DaliException e) {
15765       {
15766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15767       };
15768     } catch (...) {
15769       {
15770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15771       };
15772     }
15773   }
15774
15775   jresult = result;
15776   return jresult;
15777 }
15778
15779
15780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15781   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15782
15783   arg1 = (Dali::Property::Key *)jarg1;
15784   {
15785     try {
15786       delete arg1;
15787     } catch (std::out_of_range& e) {
15788       {
15789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15790       };
15791     } catch (std::exception& e) {
15792       {
15793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15794       };
15795     } catch (Dali::DaliException e) {
15796       {
15797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15798       };
15799     } catch (...) {
15800       {
15801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15802       };
15803     }
15804   }
15805
15806 }
15807
15808
15809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15810   void * jresult ;
15811   Dali::Property::Map *result = 0 ;
15812
15813   {
15814     try {
15815       result = (Dali::Property::Map *)new Dali::Property::Map();
15816     } catch (std::out_of_range& e) {
15817       {
15818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15819       };
15820     } catch (std::exception& e) {
15821       {
15822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15823       };
15824     } catch (Dali::DaliException e) {
15825       {
15826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15827       };
15828     } catch (...) {
15829       {
15830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15831       };
15832     }
15833   }
15834
15835   jresult = (void *)result;
15836   return jresult;
15837 }
15838
15839
15840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15841   void * jresult ;
15842   Dali::Property::Map *arg1 = 0 ;
15843   Dali::Property::Map *result = 0 ;
15844
15845   arg1 = (Dali::Property::Map *)jarg1;
15846   if (!arg1) {
15847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15848     return 0;
15849   }
15850   {
15851     try {
15852       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15853     } catch (std::out_of_range& e) {
15854       {
15855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15856       };
15857     } catch (std::exception& e) {
15858       {
15859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15860       };
15861     } catch (Dali::DaliException e) {
15862       {
15863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15864       };
15865     } catch (...) {
15866       {
15867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15868       };
15869     }
15870   }
15871
15872   jresult = (void *)result;
15873   return jresult;
15874 }
15875
15876
15877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15878   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15879
15880   arg1 = (Dali::Property::Map *)jarg1;
15881   {
15882     try {
15883       delete arg1;
15884     } catch (std::out_of_range& e) {
15885       {
15886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15887       };
15888     } catch (std::exception& e) {
15889       {
15890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15891       };
15892     } catch (Dali::DaliException e) {
15893       {
15894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15895       };
15896     } catch (...) {
15897       {
15898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15899       };
15900     }
15901   }
15902
15903 }
15904
15905
15906 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15907   unsigned long jresult ;
15908   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15909   Dali::Property::Map::SizeType result;
15910
15911   arg1 = (Dali::Property::Map *)jarg1;
15912   {
15913     try {
15914       result = ((Dali::Property::Map const *)arg1)->Count();
15915     } catch (std::out_of_range& e) {
15916       {
15917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15918       };
15919     } catch (std::exception& e) {
15920       {
15921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15922       };
15923     } catch (Dali::DaliException e) {
15924       {
15925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15926       };
15927     } catch (...) {
15928       {
15929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15930       };
15931     }
15932   }
15933
15934   jresult = (unsigned long)result;
15935   return jresult;
15936 }
15937
15938
15939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15940   unsigned int jresult ;
15941   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15942   bool result;
15943
15944   arg1 = (Dali::Property::Map *)jarg1;
15945   {
15946     try {
15947       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15948     } catch (std::out_of_range& e) {
15949       {
15950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15951       };
15952     } catch (std::exception& e) {
15953       {
15954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15955       };
15956     } catch (Dali::DaliException e) {
15957       {
15958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15959       };
15960     } catch (...) {
15961       {
15962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15963       };
15964     }
15965   }
15966
15967   jresult = result;
15968   return jresult;
15969 }
15970
15971
15972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15973   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15974   char *arg2 = (char *) 0 ;
15975   Dali::Property::Value *arg3 = 0 ;
15976
15977   arg1 = (Dali::Property::Map *)jarg1;
15978   arg2 = (char *)jarg2;
15979   arg3 = (Dali::Property::Value *)jarg3;
15980   if (!arg3) {
15981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15982     return ;
15983   }
15984   {
15985     try {
15986       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15987     } catch (std::out_of_range& e) {
15988       {
15989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15990       };
15991     } catch (std::exception& e) {
15992       {
15993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15994       };
15995     } catch (Dali::DaliException e) {
15996       {
15997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15998       };
15999     } catch (...) {
16000       {
16001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16002       };
16003     }
16004   }
16005
16006 }
16007
16008
16009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16010   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16011   Dali::Property::Index arg2 ;
16012   Dali::Property::Value *arg3 = 0 ;
16013
16014   arg1 = (Dali::Property::Map *)jarg1;
16015   arg2 = (Dali::Property::Index)jarg2;
16016   arg3 = (Dali::Property::Value *)jarg3;
16017   if (!arg3) {
16018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16019     return ;
16020   }
16021   {
16022     try {
16023       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16024     } catch (std::out_of_range& e) {
16025       {
16026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16027       };
16028     } catch (std::exception& e) {
16029       {
16030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16031       };
16032     } catch (Dali::DaliException e) {
16033       {
16034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16035       };
16036     } catch (...) {
16037       {
16038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16039       };
16040     }
16041   }
16042
16043 }
16044
16045
16046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16047   void * jresult ;
16048   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16049   char *arg2 = (char *) 0 ;
16050   Dali::Property::Value *arg3 = 0 ;
16051   Dali::Property::Map *result = 0 ;
16052
16053   arg1 = (Dali::Property::Map *)jarg1;
16054   arg2 = (char *)jarg2;
16055   arg3 = (Dali::Property::Value *)jarg3;
16056   if (!arg3) {
16057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16058     return 0;
16059   }
16060   {
16061     try {
16062       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16063     } catch (std::out_of_range& e) {
16064       {
16065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16066       };
16067     } catch (std::exception& e) {
16068       {
16069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16070       };
16071     } catch (Dali::DaliException e) {
16072       {
16073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16074       };
16075     } catch (...) {
16076       {
16077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16078       };
16079     }
16080   }
16081
16082   jresult = (void *)result;
16083   return jresult;
16084 }
16085
16086
16087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16088   void * jresult ;
16089   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16090   Dali::Property::Index arg2 ;
16091   Dali::Property::Value *arg3 = 0 ;
16092   Dali::Property::Map *result = 0 ;
16093
16094   arg1 = (Dali::Property::Map *)jarg1;
16095   arg2 = (Dali::Property::Index)jarg2;
16096   arg3 = (Dali::Property::Value *)jarg3;
16097   if (!arg3) {
16098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16099     return 0;
16100   }
16101   {
16102     try {
16103       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16104     } catch (std::out_of_range& e) {
16105       {
16106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16107       };
16108     } catch (std::exception& e) {
16109       {
16110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16111       };
16112     } catch (Dali::DaliException e) {
16113       {
16114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16115       };
16116     } catch (...) {
16117       {
16118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16119       };
16120     }
16121   }
16122
16123   jresult = (void *)result;
16124   return jresult;
16125 }
16126
16127
16128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16129   void * jresult ;
16130   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16131   Dali::Property::Map::SizeType arg2 ;
16132   Dali::Property::Value *result = 0 ;
16133
16134   arg1 = (Dali::Property::Map *)jarg1;
16135   arg2 = (Dali::Property::Map::SizeType)jarg2;
16136   {
16137     try {
16138       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16139     } catch (std::out_of_range& e) {
16140       {
16141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (std::exception& e) {
16144       {
16145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16146       };
16147     } catch (Dali::DaliException e) {
16148       {
16149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16150       };
16151     } catch (...) {
16152       {
16153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16154       };
16155     }
16156   }
16157
16158   jresult = (void *)result;
16159   return jresult;
16160 }
16161
16162
16163 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16164   char * jresult ;
16165   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16166   Dali::Property::Map::SizeType arg2 ;
16167   std::string *result = 0 ;
16168
16169   arg1 = (Dali::Property::Map *)jarg1;
16170   arg2 = (Dali::Property::Map::SizeType)jarg2;
16171   {
16172     try {
16173       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16174     } catch (std::out_of_range& e) {
16175       {
16176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16177       };
16178     } catch (std::exception& e) {
16179       {
16180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16181       };
16182     } catch (Dali::DaliException e) {
16183       {
16184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16185       };
16186     } catch (...) {
16187       {
16188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16189       };
16190     }
16191   }
16192
16193   jresult = SWIG_csharp_string_callback(result->c_str());
16194   return jresult;
16195 }
16196
16197
16198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16199   void * jresult ;
16200   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16201   Dali::Property::Map::SizeType arg2 ;
16202   SwigValueWrapper< Dali::Property::Key > result;
16203
16204   arg1 = (Dali::Property::Map *)jarg1;
16205   arg2 = (Dali::Property::Map::SizeType)jarg2;
16206   {
16207     try {
16208       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16209     } catch (std::out_of_range& e) {
16210       {
16211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16212       };
16213     } catch (std::exception& e) {
16214       {
16215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16216       };
16217     } catch (Dali::DaliException e) {
16218       {
16219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16220       };
16221     } catch (...) {
16222       {
16223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16224       };
16225     }
16226   }
16227
16228   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16229   return jresult;
16230 }
16231
16232
16233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16234   void * jresult ;
16235   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16236   Dali::Property::Map::SizeType arg2 ;
16237   StringValuePair *result = 0 ;
16238
16239   arg1 = (Dali::Property::Map *)jarg1;
16240   arg2 = (Dali::Property::Map::SizeType)jarg2;
16241   {
16242     try {
16243       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16244     } catch (std::out_of_range& e) {
16245       {
16246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16247       };
16248     } catch (std::exception& e) {
16249       {
16250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16251       };
16252     } catch (Dali::DaliException e) {
16253       {
16254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16255       };
16256     } catch (...) {
16257       {
16258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16259       };
16260     }
16261   }
16262
16263   jresult = (void *)result;
16264   return jresult;
16265 }
16266
16267
16268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16269   void * jresult ;
16270   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16271   char *arg2 = (char *) 0 ;
16272   Dali::Property::Value *result = 0 ;
16273
16274   arg1 = (Dali::Property::Map *)jarg1;
16275   arg2 = (char *)jarg2;
16276   {
16277     try {
16278       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16279     } catch (std::out_of_range& e) {
16280       {
16281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16282       };
16283     } catch (std::exception& e) {
16284       {
16285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16286       };
16287     } catch (Dali::DaliException e) {
16288       {
16289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16290       };
16291     } catch (...) {
16292       {
16293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16294       };
16295     }
16296   }
16297
16298   jresult = (void *)result;
16299   return jresult;
16300 }
16301
16302
16303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16304   void * jresult ;
16305   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16306   Dali::Property::Index arg2 ;
16307   Dali::Property::Value *result = 0 ;
16308
16309   arg1 = (Dali::Property::Map *)jarg1;
16310   arg2 = (Dali::Property::Index)jarg2;
16311   {
16312     try {
16313       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16314     } catch (std::out_of_range& e) {
16315       {
16316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16317       };
16318     } catch (std::exception& e) {
16319       {
16320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16321       };
16322     } catch (Dali::DaliException e) {
16323       {
16324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16325       };
16326     } catch (...) {
16327       {
16328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16329       };
16330     }
16331   }
16332
16333   jresult = (void *)result;
16334   return jresult;
16335 }
16336
16337
16338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16339   void * jresult ;
16340   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16341   Dali::Property::Index arg2 ;
16342   std::string *arg3 = 0 ;
16343   Dali::Property::Value *result = 0 ;
16344
16345   arg1 = (Dali::Property::Map *)jarg1;
16346   arg2 = (Dali::Property::Index)jarg2;
16347   if (!jarg3) {
16348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16349     return 0;
16350   }
16351   std::string arg3_str(jarg3);
16352   arg3 = &arg3_str;
16353   {
16354     try {
16355       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16356     } catch (std::out_of_range& e) {
16357       {
16358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16359       };
16360     } catch (std::exception& e) {
16361       {
16362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16363       };
16364     } catch (Dali::DaliException e) {
16365       {
16366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16367       };
16368     } catch (...) {
16369       {
16370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16371       };
16372     }
16373   }
16374
16375   jresult = (void *)result;
16376
16377   //argout typemap for const std::string&
16378
16379   return jresult;
16380 }
16381
16382
16383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16384   void * jresult ;
16385   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16386   std::string *arg2 = 0 ;
16387   Dali::Property::Type arg3 ;
16388   Dali::Property::Value *result = 0 ;
16389
16390   arg1 = (Dali::Property::Map *)jarg1;
16391   if (!jarg2) {
16392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16393     return 0;
16394   }
16395   std::string arg2_str(jarg2);
16396   arg2 = &arg2_str;
16397   arg3 = (Dali::Property::Type)jarg3;
16398   {
16399     try {
16400       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16401     } catch (std::out_of_range& e) {
16402       {
16403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16404       };
16405     } catch (std::exception& e) {
16406       {
16407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16408       };
16409     } catch (Dali::DaliException e) {
16410       {
16411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16412       };
16413     } catch (...) {
16414       {
16415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16416       };
16417     }
16418   }
16419
16420   jresult = (void *)result;
16421
16422   //argout typemap for const std::string&
16423
16424   return jresult;
16425 }
16426
16427
16428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16429   void * jresult ;
16430   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16431   Dali::Property::Index arg2 ;
16432   Dali::Property::Type arg3 ;
16433   Dali::Property::Value *result = 0 ;
16434
16435   arg1 = (Dali::Property::Map *)jarg1;
16436   arg2 = (Dali::Property::Index)jarg2;
16437   arg3 = (Dali::Property::Type)jarg3;
16438   {
16439     try {
16440       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16441     } catch (std::out_of_range& e) {
16442       {
16443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16444       };
16445     } catch (std::exception& e) {
16446       {
16447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16448       };
16449     } catch (Dali::DaliException e) {
16450       {
16451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16452       };
16453     } catch (...) {
16454       {
16455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16456       };
16457     }
16458   }
16459
16460   jresult = (void *)result;
16461   return jresult;
16462 }
16463
16464
16465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16466   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16467
16468   arg1 = (Dali::Property::Map *)jarg1;
16469   {
16470     try {
16471       (arg1)->Clear();
16472     } catch (std::out_of_range& e) {
16473       {
16474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16475       };
16476     } catch (std::exception& e) {
16477       {
16478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16479       };
16480     } catch (Dali::DaliException e) {
16481       {
16482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16483       };
16484     } catch (...) {
16485       {
16486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16487       };
16488     }
16489   }
16490
16491 }
16492
16493
16494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16495   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16496   Dali::Property::Map *arg2 = 0 ;
16497
16498   arg1 = (Dali::Property::Map *)jarg1;
16499   arg2 = (Dali::Property::Map *)jarg2;
16500   if (!arg2) {
16501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16502     return ;
16503   }
16504   {
16505     try {
16506       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16507     } catch (std::out_of_range& e) {
16508       {
16509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16510       };
16511     } catch (std::exception& e) {
16512       {
16513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16514       };
16515     } catch (Dali::DaliException e) {
16516       {
16517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16518       };
16519     } catch (...) {
16520       {
16521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16522       };
16523     }
16524   }
16525
16526 }
16527
16528
16529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16530   void * jresult ;
16531   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16532   std::string *arg2 = 0 ;
16533   Dali::Property::Value *result = 0 ;
16534
16535   arg1 = (Dali::Property::Map *)jarg1;
16536   if (!jarg2) {
16537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16538     return 0;
16539   }
16540   std::string arg2_str(jarg2);
16541   arg2 = &arg2_str;
16542   {
16543     try {
16544       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16545     } catch (std::out_of_range& e) {
16546       {
16547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16548       };
16549     } catch (std::exception& e) {
16550       {
16551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16552       };
16553     } catch (Dali::DaliException e) {
16554       {
16555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16556       };
16557     } catch (...) {
16558       {
16559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16560       };
16561     }
16562   }
16563
16564   jresult = (void *)result;
16565
16566   //argout typemap for const std::string&
16567
16568   return jresult;
16569 }
16570
16571
16572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16573   void * jresult ;
16574   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16575   Dali::Property::Index arg2 ;
16576   Dali::Property::Value *result = 0 ;
16577
16578   arg1 = (Dali::Property::Map *)jarg1;
16579   arg2 = (Dali::Property::Index)jarg2;
16580   {
16581     try {
16582       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16583     } catch (std::out_of_range& e) {
16584       {
16585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16586       };
16587     } catch (std::exception& e) {
16588       {
16589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16590       };
16591     } catch (Dali::DaliException e) {
16592       {
16593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16594       };
16595     } catch (...) {
16596       {
16597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16598       };
16599     }
16600   }
16601
16602   jresult = (void *)result;
16603   return jresult;
16604 }
16605
16606
16607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16608   void * jresult ;
16609   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16610   Dali::Property::Map *arg2 = 0 ;
16611   Dali::Property::Map *result = 0 ;
16612
16613   arg1 = (Dali::Property::Map *)jarg1;
16614   arg2 = (Dali::Property::Map *)jarg2;
16615   if (!arg2) {
16616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16617     return 0;
16618   }
16619   {
16620     try {
16621       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16622     } catch (std::out_of_range& e) {
16623       {
16624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16625       };
16626     } catch (std::exception& e) {
16627       {
16628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16629       };
16630     } catch (Dali::DaliException e) {
16631       {
16632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16633       };
16634     } catch (...) {
16635       {
16636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16637       };
16638     }
16639   }
16640
16641   jresult = (void *)result;
16642   return jresult;
16643 }
16644
16645
16646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16647   void * jresult ;
16648   Dali::Property::Value *result = 0 ;
16649
16650   {
16651     try {
16652       result = (Dali::Property::Value *)new Dali::Property::Value();
16653     } catch (std::out_of_range& e) {
16654       {
16655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16656       };
16657     } catch (std::exception& e) {
16658       {
16659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16660       };
16661     } catch (Dali::DaliException e) {
16662       {
16663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16664       };
16665     } catch (...) {
16666       {
16667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16668       };
16669     }
16670   }
16671
16672   jresult = (void *)result;
16673   return jresult;
16674 }
16675
16676
16677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16678   void * jresult ;
16679   bool arg1 ;
16680   Dali::Property::Value *result = 0 ;
16681
16682   arg1 = jarg1 ? true : false;
16683   {
16684     try {
16685       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16686     } catch (std::out_of_range& e) {
16687       {
16688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16689       };
16690     } catch (std::exception& e) {
16691       {
16692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16693       };
16694     } catch (Dali::DaliException e) {
16695       {
16696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16697       };
16698     } catch (...) {
16699       {
16700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16701       };
16702     }
16703   }
16704
16705   jresult = (void *)result;
16706   return jresult;
16707 }
16708
16709
16710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16711   void * jresult ;
16712   int arg1 ;
16713   Dali::Property::Value *result = 0 ;
16714
16715   arg1 = (int)jarg1;
16716   {
16717     try {
16718       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16719     } catch (std::out_of_range& e) {
16720       {
16721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16722       };
16723     } catch (std::exception& e) {
16724       {
16725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16726       };
16727     } catch (Dali::DaliException e) {
16728       {
16729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16730       };
16731     } catch (...) {
16732       {
16733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16734       };
16735     }
16736   }
16737
16738   jresult = (void *)result;
16739   return jresult;
16740 }
16741
16742
16743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16744   void * jresult ;
16745   float arg1 ;
16746   Dali::Property::Value *result = 0 ;
16747
16748   arg1 = (float)jarg1;
16749   {
16750     try {
16751       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16752     } catch (std::out_of_range& e) {
16753       {
16754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16755       };
16756     } catch (std::exception& e) {
16757       {
16758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16759       };
16760     } catch (Dali::DaliException e) {
16761       {
16762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16763       };
16764     } catch (...) {
16765       {
16766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16767       };
16768     }
16769   }
16770
16771   jresult = (void *)result;
16772   return jresult;
16773 }
16774
16775
16776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16777   void * jresult ;
16778   Dali::Vector2 *arg1 = 0 ;
16779   Dali::Property::Value *result = 0 ;
16780
16781   arg1 = (Dali::Vector2 *)jarg1;
16782   if (!arg1) {
16783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16784     return 0;
16785   }
16786   {
16787     try {
16788       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16789     } catch (std::out_of_range& e) {
16790       {
16791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16792       };
16793     } catch (std::exception& e) {
16794       {
16795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16796       };
16797     } catch (Dali::DaliException e) {
16798       {
16799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16800       };
16801     } catch (...) {
16802       {
16803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16804       };
16805     }
16806   }
16807
16808   jresult = (void *)result;
16809   return jresult;
16810 }
16811
16812
16813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16814   void * jresult ;
16815   Dali::Vector3 *arg1 = 0 ;
16816   Dali::Property::Value *result = 0 ;
16817
16818   arg1 = (Dali::Vector3 *)jarg1;
16819   if (!arg1) {
16820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16821     return 0;
16822   }
16823   {
16824     try {
16825       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16826     } catch (std::out_of_range& e) {
16827       {
16828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16829       };
16830     } catch (std::exception& e) {
16831       {
16832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16833       };
16834     } catch (Dali::DaliException e) {
16835       {
16836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16837       };
16838     } catch (...) {
16839       {
16840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16841       };
16842     }
16843   }
16844
16845   jresult = (void *)result;
16846   return jresult;
16847 }
16848
16849
16850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16851   void * jresult ;
16852   Dali::Vector4 *arg1 = 0 ;
16853   Dali::Property::Value *result = 0 ;
16854
16855   arg1 = (Dali::Vector4 *)jarg1;
16856   if (!arg1) {
16857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16858     return 0;
16859   }
16860   {
16861     try {
16862       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16863     } catch (std::out_of_range& e) {
16864       {
16865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16866       };
16867     } catch (std::exception& e) {
16868       {
16869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16870       };
16871     } catch (Dali::DaliException e) {
16872       {
16873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16874       };
16875     } catch (...) {
16876       {
16877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16878       };
16879     }
16880   }
16881
16882   jresult = (void *)result;
16883   return jresult;
16884 }
16885
16886
16887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16888   void * jresult ;
16889   Dali::Matrix3 *arg1 = 0 ;
16890   Dali::Property::Value *result = 0 ;
16891
16892   arg1 = (Dali::Matrix3 *)jarg1;
16893   if (!arg1) {
16894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16895     return 0;
16896   }
16897   {
16898     try {
16899       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16900     } catch (std::out_of_range& e) {
16901       {
16902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16903       };
16904     } catch (std::exception& e) {
16905       {
16906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16907       };
16908     } catch (Dali::DaliException e) {
16909       {
16910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16911       };
16912     } catch (...) {
16913       {
16914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16915       };
16916     }
16917   }
16918
16919   jresult = (void *)result;
16920   return jresult;
16921 }
16922
16923
16924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16925   void * jresult ;
16926   Dali::Matrix *arg1 = 0 ;
16927   Dali::Property::Value *result = 0 ;
16928
16929   arg1 = (Dali::Matrix *)jarg1;
16930   if (!arg1) {
16931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16932     return 0;
16933   }
16934   {
16935     try {
16936       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16937     } catch (std::out_of_range& e) {
16938       {
16939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16940       };
16941     } catch (std::exception& e) {
16942       {
16943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16944       };
16945     } catch (Dali::DaliException e) {
16946       {
16947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16948       };
16949     } catch (...) {
16950       {
16951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16952       };
16953     }
16954   }
16955
16956   jresult = (void *)result;
16957   return jresult;
16958 }
16959
16960
16961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16962   void * jresult ;
16963   Dali::Rect< int > *arg1 = 0 ;
16964   Dali::Property::Value *result = 0 ;
16965
16966   arg1 = (Dali::Rect< int > *)jarg1;
16967   if (!arg1) {
16968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16969     return 0;
16970   }
16971   {
16972     try {
16973       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16974     } catch (std::out_of_range& e) {
16975       {
16976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16977       };
16978     } catch (std::exception& e) {
16979       {
16980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16981       };
16982     } catch (Dali::DaliException e) {
16983       {
16984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16985       };
16986     } catch (...) {
16987       {
16988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16989       };
16990     }
16991   }
16992
16993   jresult = (void *)result;
16994   return jresult;
16995 }
16996
16997
16998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16999   void * jresult ;
17000   Dali::AngleAxis *arg1 = 0 ;
17001   Dali::Property::Value *result = 0 ;
17002
17003   arg1 = (Dali::AngleAxis *)jarg1;
17004   if (!arg1) {
17005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17006     return 0;
17007   }
17008   {
17009     try {
17010       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17011     } catch (std::out_of_range& e) {
17012       {
17013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17014       };
17015     } catch (std::exception& e) {
17016       {
17017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17018       };
17019     } catch (Dali::DaliException e) {
17020       {
17021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17022       };
17023     } catch (...) {
17024       {
17025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17026       };
17027     }
17028   }
17029
17030   jresult = (void *)result;
17031   return jresult;
17032 }
17033
17034
17035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17036   void * jresult ;
17037   Dali::Quaternion *arg1 = 0 ;
17038   Dali::Property::Value *result = 0 ;
17039
17040   arg1 = (Dali::Quaternion *)jarg1;
17041   if (!arg1) {
17042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17043     return 0;
17044   }
17045   {
17046     try {
17047       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17048     } catch (std::out_of_range& e) {
17049       {
17050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (std::exception& e) {
17053       {
17054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17055       };
17056     } catch (Dali::DaliException e) {
17057       {
17058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17059       };
17060     } catch (...) {
17061       {
17062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17063       };
17064     }
17065   }
17066
17067   jresult = (void *)result;
17068   return jresult;
17069 }
17070
17071
17072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17073   void * jresult ;
17074   std::string *arg1 = 0 ;
17075   Dali::Property::Value *result = 0 ;
17076
17077   if (!jarg1) {
17078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17079     return 0;
17080   }
17081   std::string arg1_str(jarg1);
17082   arg1 = &arg1_str;
17083   {
17084     try {
17085       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17086     } catch (std::out_of_range& e) {
17087       {
17088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17089       };
17090     } catch (std::exception& e) {
17091       {
17092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17093       };
17094     } catch (Dali::DaliException e) {
17095       {
17096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17097       };
17098     } catch (...) {
17099       {
17100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17101       };
17102     }
17103   }
17104
17105   jresult = (void *)result;
17106
17107   //argout typemap for const std::string&
17108
17109   return jresult;
17110 }
17111
17112
17113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17114   void * jresult ;
17115   Dali::Property::Array *arg1 = 0 ;
17116   Dali::Property::Value *result = 0 ;
17117
17118   arg1 = (Dali::Property::Array *)jarg1;
17119   if (!arg1) {
17120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17121     return 0;
17122   }
17123   {
17124     try {
17125       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17126     } catch (std::out_of_range& e) {
17127       {
17128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17129       };
17130     } catch (std::exception& e) {
17131       {
17132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17133       };
17134     } catch (Dali::DaliException e) {
17135       {
17136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17137       };
17138     } catch (...) {
17139       {
17140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17141       };
17142     }
17143   }
17144
17145   jresult = (void *)result;
17146   return jresult;
17147 }
17148
17149
17150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17151   void * jresult ;
17152   Dali::Property::Map *arg1 = 0 ;
17153   Dali::Property::Value *result = 0 ;
17154
17155   arg1 = (Dali::Property::Map *)jarg1;
17156   if (!arg1) {
17157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17158     return 0;
17159   }
17160   {
17161     try {
17162       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17163     } catch (std::out_of_range& e) {
17164       {
17165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (std::exception& e) {
17168       {
17169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17170       };
17171     } catch (Dali::DaliException e) {
17172       {
17173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17174       };
17175     } catch (...) {
17176       {
17177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17178       };
17179     }
17180   }
17181
17182   jresult = (void *)result;
17183   return jresult;
17184 }
17185
17186
17187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17188   void * jresult ;
17189   Extents *arg1 = 0 ;
17190   Dali::Property::Value *result = 0 ;
17191
17192   arg1 = (Extents *)jarg1;
17193   if (!arg1) {
17194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17195     return 0;
17196   }
17197   {
17198     try {
17199       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17200     } catch (std::out_of_range& e) {
17201       {
17202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17203       };
17204     } catch (std::exception& e) {
17205       {
17206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17207       };
17208     } catch (...) {
17209       {
17210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17211       };
17212     }
17213   }
17214   jresult = (void *)result;
17215   return jresult;
17216 }
17217
17218
17219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17220   void * jresult ;
17221   Dali::Property::Type arg1 ;
17222   Dali::Property::Value *result = 0 ;
17223
17224   arg1 = (Dali::Property::Type)jarg1;
17225   {
17226     try {
17227       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17228     } catch (std::out_of_range& e) {
17229       {
17230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17231       };
17232     } catch (std::exception& e) {
17233       {
17234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17235       };
17236     } catch (Dali::DaliException e) {
17237       {
17238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17239       };
17240     } catch (...) {
17241       {
17242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17243       };
17244     }
17245   }
17246
17247   jresult = (void *)result;
17248   return jresult;
17249 }
17250
17251
17252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17253   void * jresult ;
17254   Dali::Property::Value *arg1 = 0 ;
17255   Dali::Property::Value *result = 0 ;
17256
17257   arg1 = (Dali::Property::Value *)jarg1;
17258   if (!arg1) {
17259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17260     return 0;
17261   }
17262   {
17263     try {
17264       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17265     } catch (std::out_of_range& e) {
17266       {
17267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17268       };
17269     } catch (std::exception& e) {
17270       {
17271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17272       };
17273     } catch (Dali::DaliException e) {
17274       {
17275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17276       };
17277     } catch (...) {
17278       {
17279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17280       };
17281     }
17282   }
17283
17284   jresult = (void *)result;
17285   return jresult;
17286 }
17287
17288
17289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17290   void * jresult ;
17291   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17292   Dali::Property::Value *arg2 = 0 ;
17293   Dali::Property::Value *result = 0 ;
17294
17295   arg1 = (Dali::Property::Value *)jarg1;
17296   arg2 = (Dali::Property::Value *)jarg2;
17297   if (!arg2) {
17298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17299     return 0;
17300   }
17301   {
17302     try {
17303       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17304     } catch (std::out_of_range& e) {
17305       {
17306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (std::exception& e) {
17309       {
17310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17311       };
17312     } catch (Dali::DaliException e) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17315       };
17316     } catch (...) {
17317       {
17318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17319       };
17320     }
17321   }
17322
17323   jresult = (void *)result;
17324   return jresult;
17325 }
17326
17327
17328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17329   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17330
17331   arg1 = (Dali::Property::Value *)jarg1;
17332   {
17333     try {
17334       delete arg1;
17335     } catch (std::out_of_range& e) {
17336       {
17337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17338       };
17339     } catch (std::exception& e) {
17340       {
17341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17342       };
17343     } catch (Dali::DaliException e) {
17344       {
17345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17346       };
17347     } catch (...) {
17348       {
17349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17350       };
17351     }
17352   }
17353
17354 }
17355
17356
17357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17358   int jresult ;
17359   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17360   Dali::Property::Type result;
17361
17362   arg1 = (Dali::Property::Value *)jarg1;
17363   {
17364     try {
17365       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17366     } catch (std::out_of_range& e) {
17367       {
17368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17369       };
17370     } catch (std::exception& e) {
17371       {
17372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17373       };
17374     } catch (Dali::DaliException e) {
17375       {
17376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17377       };
17378     } catch (...) {
17379       {
17380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17381       };
17382     }
17383   }
17384
17385   jresult = (int)result;
17386   return jresult;
17387 }
17388
17389
17390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17391   unsigned int jresult ;
17392   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17393   bool *arg2 = 0 ;
17394   bool result;
17395
17396   arg1 = (Dali::Property::Value *)jarg1;
17397   arg2 = (bool *)jarg2;
17398   {
17399     try {
17400       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17401     } catch (std::out_of_range& e) {
17402       {
17403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17404       };
17405     } catch (std::exception& e) {
17406       {
17407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17408       };
17409     } catch (Dali::DaliException e) {
17410       {
17411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17412       };
17413     } catch (...) {
17414       {
17415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17416       };
17417     }
17418   }
17419
17420   jresult = result;
17421   return jresult;
17422 }
17423
17424
17425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17426   unsigned int jresult ;
17427   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17428   float *arg2 = 0 ;
17429   bool result;
17430
17431   arg1 = (Dali::Property::Value *)jarg1;
17432   arg2 = (float *)jarg2;
17433   {
17434     try {
17435       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17436     } catch (std::out_of_range& e) {
17437       {
17438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17439       };
17440     } catch (std::exception& e) {
17441       {
17442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17443       };
17444     } catch (Dali::DaliException e) {
17445       {
17446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17447       };
17448     } catch (...) {
17449       {
17450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17451       };
17452     }
17453   }
17454
17455   jresult = result;
17456   return jresult;
17457 }
17458
17459
17460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17461   unsigned int jresult ;
17462   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17463   int *arg2 = 0 ;
17464   bool result;
17465
17466   arg1 = (Dali::Property::Value *)jarg1;
17467   arg2 = (int *)jarg2;
17468   {
17469     try {
17470       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17471     } catch (std::out_of_range& e) {
17472       {
17473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17474       };
17475     } catch (std::exception& e) {
17476       {
17477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17478       };
17479     } catch (Dali::DaliException e) {
17480       {
17481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17482       };
17483     } catch (...) {
17484       {
17485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17486       };
17487     }
17488   }
17489
17490   jresult = result;
17491   return jresult;
17492 }
17493
17494
17495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17496   unsigned int jresult ;
17497   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17498   Dali::Rect< int > *arg2 = 0 ;
17499   bool result;
17500
17501   arg1 = (Dali::Property::Value *)jarg1;
17502   arg2 = (Dali::Rect< int > *)jarg2;
17503   if (!arg2) {
17504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17505     return 0;
17506   }
17507   {
17508     try {
17509       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17510     } catch (std::out_of_range& e) {
17511       {
17512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (std::exception& e) {
17515       {
17516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17517       };
17518     } catch (Dali::DaliException e) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17521       };
17522     } catch (...) {
17523       {
17524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17525       };
17526     }
17527   }
17528
17529   jresult = result;
17530   return jresult;
17531 }
17532
17533
17534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17535   unsigned int jresult ;
17536   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17537   Dali::Vector2 *arg2 = 0 ;
17538   bool result;
17539
17540   arg1 = (Dali::Property::Value *)jarg1;
17541   arg2 = (Dali::Vector2 *)jarg2;
17542   if (!arg2) {
17543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17544     return 0;
17545   }
17546   {
17547     try {
17548       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17549     } catch (std::out_of_range& e) {
17550       {
17551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17552       };
17553     } catch (std::exception& e) {
17554       {
17555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17556       };
17557     } catch (Dali::DaliException e) {
17558       {
17559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17560       };
17561     } catch (...) {
17562       {
17563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17564       };
17565     }
17566   }
17567
17568   jresult = result;
17569   return jresult;
17570 }
17571
17572
17573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17574   unsigned int jresult ;
17575   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17576   Dali::Vector3 *arg2 = 0 ;
17577   bool result;
17578
17579   arg1 = (Dali::Property::Value *)jarg1;
17580   arg2 = (Dali::Vector3 *)jarg2;
17581   if (!arg2) {
17582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17583     return 0;
17584   }
17585   {
17586     try {
17587       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17588     } catch (std::out_of_range& e) {
17589       {
17590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17591       };
17592     } catch (std::exception& e) {
17593       {
17594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17595       };
17596     } catch (Dali::DaliException e) {
17597       {
17598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17599       };
17600     } catch (...) {
17601       {
17602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17603       };
17604     }
17605   }
17606
17607   jresult = result;
17608   return jresult;
17609 }
17610
17611
17612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17613   unsigned int jresult ;
17614   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17615   Dali::Vector4 *arg2 = 0 ;
17616   bool result;
17617
17618   arg1 = (Dali::Property::Value *)jarg1;
17619   arg2 = (Dali::Vector4 *)jarg2;
17620   if (!arg2) {
17621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17622     return 0;
17623   }
17624   {
17625     try {
17626       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17627     } catch (std::out_of_range& e) {
17628       {
17629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17630       };
17631     } catch (std::exception& e) {
17632       {
17633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17634       };
17635     } catch (Dali::DaliException e) {
17636       {
17637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17638       };
17639     } catch (...) {
17640       {
17641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17642       };
17643     }
17644   }
17645
17646   jresult = result;
17647   return jresult;
17648 }
17649
17650
17651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17652   unsigned int jresult ;
17653   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17654   Dali::Matrix3 *arg2 = 0 ;
17655   bool result;
17656
17657   arg1 = (Dali::Property::Value *)jarg1;
17658   arg2 = (Dali::Matrix3 *)jarg2;
17659   if (!arg2) {
17660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17661     return 0;
17662   }
17663   {
17664     try {
17665       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17666     } catch (std::out_of_range& e) {
17667       {
17668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17669       };
17670     } catch (std::exception& e) {
17671       {
17672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17673       };
17674     } catch (Dali::DaliException e) {
17675       {
17676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17677       };
17678     } catch (...) {
17679       {
17680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17681       };
17682     }
17683   }
17684
17685   jresult = result;
17686   return jresult;
17687 }
17688
17689
17690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17691   unsigned int jresult ;
17692   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17693   Dali::Matrix *arg2 = 0 ;
17694   bool result;
17695
17696   arg1 = (Dali::Property::Value *)jarg1;
17697   arg2 = (Dali::Matrix *)jarg2;
17698   if (!arg2) {
17699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17700     return 0;
17701   }
17702   {
17703     try {
17704       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17705     } catch (std::out_of_range& e) {
17706       {
17707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17708       };
17709     } catch (std::exception& e) {
17710       {
17711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17712       };
17713     } catch (Dali::DaliException e) {
17714       {
17715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17716       };
17717     } catch (...) {
17718       {
17719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17720       };
17721     }
17722   }
17723
17724   jresult = result;
17725   return jresult;
17726 }
17727
17728
17729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17730   unsigned int jresult ;
17731   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17732   Dali::AngleAxis *arg2 = 0 ;
17733   bool result;
17734
17735   arg1 = (Dali::Property::Value *)jarg1;
17736   arg2 = (Dali::AngleAxis *)jarg2;
17737   if (!arg2) {
17738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17739     return 0;
17740   }
17741   {
17742     try {
17743       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17744     } catch (std::out_of_range& e) {
17745       {
17746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17747       };
17748     } catch (std::exception& e) {
17749       {
17750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17751       };
17752     } catch (Dali::DaliException e) {
17753       {
17754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17755       };
17756     } catch (...) {
17757       {
17758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17759       };
17760     }
17761   }
17762
17763   jresult = result;
17764   return jresult;
17765 }
17766
17767
17768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17769   unsigned int jresult ;
17770   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17771   Dali::Quaternion *arg2 = 0 ;
17772   bool result;
17773
17774   arg1 = (Dali::Property::Value *)jarg1;
17775   arg2 = (Dali::Quaternion *)jarg2;
17776   if (!arg2) {
17777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17778     return 0;
17779   }
17780   {
17781     try {
17782       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17783     } catch (std::out_of_range& e) {
17784       {
17785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17786       };
17787     } catch (std::exception& e) {
17788       {
17789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17790       };
17791     } catch (Dali::DaliException e) {
17792       {
17793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17794       };
17795     } catch (...) {
17796       {
17797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17798       };
17799     }
17800   }
17801
17802   jresult = result;
17803   return jresult;
17804 }
17805
17806
17807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17808   unsigned int jresult ;
17809   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17810   std::string *arg2 = 0 ;
17811   bool result;
17812
17813   arg1 = (Dali::Property::Value *)jarg1;
17814
17815   //typemap in
17816   std::string temp;
17817   arg2 = &temp;
17818
17819   {
17820     try {
17821       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17822     } catch (std::out_of_range& e) {
17823       {
17824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17825       };
17826     } catch (std::exception& e) {
17827       {
17828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17829       };
17830     } catch (Dali::DaliException e) {
17831       {
17832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17833       };
17834     } catch (...) {
17835       {
17836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17837       };
17838     }
17839   }
17840
17841   jresult = result;
17842
17843   //Typemap argout in c++ file.
17844   //This will convert c++ string to c# string
17845   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17846
17847   return jresult;
17848 }
17849
17850
17851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17852   unsigned int jresult ;
17853   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17854   Dali::Property::Array *arg2 = 0 ;
17855   bool result;
17856
17857   arg1 = (Dali::Property::Value *)jarg1;
17858   arg2 = (Dali::Property::Array *)jarg2;
17859   if (!arg2) {
17860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17861     return 0;
17862   }
17863   {
17864     try {
17865       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17866     } catch (std::out_of_range& e) {
17867       {
17868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17869       };
17870     } catch (std::exception& e) {
17871       {
17872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17873       };
17874     } catch (Dali::DaliException e) {
17875       {
17876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17877       };
17878     } catch (...) {
17879       {
17880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17881       };
17882     }
17883   }
17884
17885   jresult = result;
17886   return jresult;
17887 }
17888
17889
17890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17891   unsigned int jresult ;
17892   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17893   Dali::Property::Map *arg2 = 0 ;
17894   bool result;
17895
17896   arg1 = (Dali::Property::Value *)jarg1;
17897   arg2 = (Dali::Property::Map *)jarg2;
17898   if (!arg2) {
17899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17900     return 0;
17901   }
17902   {
17903     try {
17904       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17905     } catch (std::out_of_range& e) {
17906       {
17907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17908       };
17909     } catch (std::exception& e) {
17910       {
17911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17912       };
17913     } catch (Dali::DaliException e) {
17914       {
17915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17916       };
17917     } catch (...) {
17918       {
17919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17920       };
17921     }
17922   }
17923
17924   jresult = result;
17925   return jresult;
17926 }
17927
17928
17929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17930   unsigned int jresult ;
17931   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17932   Extents *arg2 = 0 ;
17933   bool result;
17934
17935   arg1 = (Dali::Property::Value *)jarg1;
17936   arg2 = (Extents *)jarg2;
17937   if (!arg2) {
17938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17939     return 0;
17940   }
17941   {
17942     try {
17943       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17944     } catch (std::out_of_range& e) {
17945       {
17946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17947       };
17948     } catch (std::exception& e) {
17949       {
17950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17951       };
17952     } catch (...) {
17953       {
17954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17955       };
17956     }
17957   }
17958   jresult = result;
17959   return jresult;
17960 }
17961
17962
17963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17964   void * jresult ;
17965   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17966   Dali::Property::Array *result = 0 ;
17967
17968   arg1 = (Dali::Property::Value *)jarg1;
17969   {
17970     try {
17971       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17972     } catch (std::out_of_range& e) {
17973       {
17974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17975       };
17976     } catch (std::exception& e) {
17977       {
17978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17979       };
17980     } catch (Dali::DaliException e) {
17981       {
17982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17983       };
17984     } catch (...) {
17985       {
17986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17987       };
17988     }
17989   }
17990
17991   jresult = (void *)result;
17992   return jresult;
17993 }
17994
17995
17996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17997   void * jresult ;
17998   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17999   Dali::Property::Map *result = 0 ;
18000
18001   arg1 = (Dali::Property::Value *)jarg1;
18002   {
18003     try {
18004       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18005     } catch (std::out_of_range& e) {
18006       {
18007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18008       };
18009     } catch (std::exception& e) {
18010       {
18011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18012       };
18013     } catch (Dali::DaliException e) {
18014       {
18015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18016       };
18017     } catch (...) {
18018       {
18019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18020       };
18021     }
18022   }
18023
18024   jresult = (void *)result;
18025   return jresult;
18026 }
18027
18028
18029 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18030   char * jresult ;
18031   Dali::Property::Type arg1 ;
18032   char *result = 0 ;
18033
18034   arg1 = (Dali::Property::Type)jarg1;
18035   {
18036     try {
18037       result = (char *)Dali::PropertyTypes::GetName(arg1);
18038     } catch (std::out_of_range& e) {
18039       {
18040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18041       };
18042     } catch (std::exception& e) {
18043       {
18044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18045       };
18046     } catch (Dali::DaliException e) {
18047       {
18048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18049       };
18050     } catch (...) {
18051       {
18052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18053       };
18054     }
18055   }
18056
18057   jresult = SWIG_csharp_string_callback((const char *)result);
18058   return jresult;
18059 }
18060
18061
18062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18063   unsigned int jresult ;
18064   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18065   std::string *arg2 = 0 ;
18066   Dali::Property::Map *arg3 = 0 ;
18067   bool result;
18068
18069   arg1 = (Dali::BaseObject *)jarg1;
18070   if (!jarg2) {
18071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18072     return 0;
18073   }
18074   std::string arg2_str(jarg2);
18075   arg2 = &arg2_str;
18076   arg3 = (Dali::Property::Map *)jarg3;
18077   if (!arg3) {
18078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18079     return 0;
18080   }
18081   {
18082     try {
18083       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18084     } catch (std::out_of_range& e) {
18085       {
18086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18087       };
18088     } catch (std::exception& e) {
18089       {
18090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18091       };
18092     } catch (Dali::DaliException e) {
18093       {
18094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18095       };
18096     } catch (...) {
18097       {
18098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18099       };
18100     }
18101   }
18102
18103   jresult = result;
18104
18105   //argout typemap for const std::string&
18106
18107   return jresult;
18108 }
18109
18110
18111 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18112   char * jresult ;
18113   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18114   std::string *result = 0 ;
18115
18116   arg1 = (Dali::BaseObject *)jarg1;
18117   {
18118     try {
18119       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18120     } catch (std::out_of_range& e) {
18121       {
18122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18123       };
18124     } catch (std::exception& e) {
18125       {
18126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18127       };
18128     } catch (Dali::DaliException e) {
18129       {
18130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18131       };
18132     } catch (...) {
18133       {
18134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18135       };
18136     }
18137   }
18138
18139   jresult = SWIG_csharp_string_callback(result->c_str());
18140   return jresult;
18141 }
18142
18143
18144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18145   unsigned int jresult ;
18146   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18147   Dali::TypeInfo *arg2 = 0 ;
18148   bool result;
18149
18150   arg1 = (Dali::BaseObject *)jarg1;
18151   arg2 = (Dali::TypeInfo *)jarg2;
18152   if (!arg2) {
18153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18154     return 0;
18155   }
18156   {
18157     try {
18158       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18159     } catch (std::out_of_range& e) {
18160       {
18161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18162       };
18163     } catch (std::exception& e) {
18164       {
18165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18166       };
18167     } catch (Dali::DaliException e) {
18168       {
18169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18170       };
18171     } catch (...) {
18172       {
18173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18174       };
18175     }
18176   }
18177
18178   jresult = result;
18179   return jresult;
18180 }
18181
18182
18183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18184   unsigned int jresult ;
18185   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18186   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18187   std::string *arg3 = 0 ;
18188   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18189   bool result;
18190
18191   arg1 = (Dali::BaseObject *)jarg1;
18192   arg2 = (ConnectionTrackerInterface *)jarg2;
18193   if (!jarg3) {
18194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18195     return 0;
18196   }
18197   std::string arg3_str(jarg3);
18198   arg3 = &arg3_str;
18199   arg4 = (FunctorDelegate *)jarg4;
18200   {
18201     try {
18202       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18203     } catch (std::out_of_range& e) {
18204       {
18205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18206       };
18207     } catch (std::exception& e) {
18208       {
18209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18210       };
18211     } catch (Dali::DaliException e) {
18212       {
18213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18214       };
18215     } catch (...) {
18216       {
18217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18218       };
18219     }
18220   }
18221
18222   jresult = result;
18223
18224   //argout typemap for const std::string&
18225
18226   return jresult;
18227 }
18228
18229
18230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18231   void * jresult ;
18232   Dali::BaseHandle *arg1 = 0 ;
18233   Dali::BaseObject *result = 0 ;
18234
18235   arg1 = (Dali::BaseHandle *)jarg1;
18236   if (!arg1) {
18237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18238     return 0;
18239   }
18240   {
18241     try {
18242       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18243     } catch (std::out_of_range& e) {
18244       {
18245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18246       };
18247     } catch (std::exception& e) {
18248       {
18249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18250       };
18251     } catch (Dali::DaliException e) {
18252       {
18253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18254       };
18255     } catch (...) {
18256       {
18257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18258       };
18259     }
18260   }
18261
18262   jresult = (void *)result;
18263   return jresult;
18264 }
18265
18266
18267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18268   void * jresult ;
18269   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18270   Dali::BaseHandle *result = 0 ;
18271
18272   arg1 = (Dali::BaseObject *)jarg1;
18273   {
18274     try {
18275       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18276     } catch (std::out_of_range& e) {
18277       {
18278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18279       };
18280     } catch (std::exception& e) {
18281       {
18282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18283       };
18284     } catch (Dali::DaliException e) {
18285       {
18286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18287       };
18288     } catch (...) {
18289       {
18290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18291       };
18292     }
18293   }
18294
18295   jresult = (void *)result;
18296   return jresult;
18297 }
18298
18299
18300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18301   void * jresult ;
18302   Dali::BaseHandle *result = 0 ;
18303
18304   {
18305     try {
18306       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18307     } catch (std::out_of_range& e) {
18308       {
18309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18310       };
18311     } catch (std::exception& e) {
18312       {
18313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18314       };
18315     } catch (Dali::DaliException e) {
18316       {
18317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18318       };
18319     } catch (...) {
18320       {
18321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18322       };
18323     }
18324   }
18325
18326   jresult = (void *)result;
18327   return jresult;
18328 }
18329
18330
18331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18332   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18333
18334   arg1 = (Dali::BaseHandle *)jarg1;
18335   {
18336     try {
18337       delete arg1;
18338     } catch (std::out_of_range& e) {
18339       {
18340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18341       };
18342     } catch (std::exception& e) {
18343       {
18344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18345       };
18346     } catch (Dali::DaliException e) {
18347       {
18348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18349       };
18350     } catch (...) {
18351       {
18352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18353       };
18354     }
18355   }
18356
18357 }
18358
18359
18360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18361   void * jresult ;
18362   Dali::BaseHandle *arg1 = 0 ;
18363   Dali::BaseHandle *result = 0 ;
18364
18365   arg1 = (Dali::BaseHandle *)jarg1;
18366   if (!arg1) {
18367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18368     return 0;
18369   }
18370   {
18371     try {
18372       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18373     } catch (std::out_of_range& e) {
18374       {
18375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18376       };
18377     } catch (std::exception& e) {
18378       {
18379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18380       };
18381     } catch (Dali::DaliException e) {
18382       {
18383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18384       };
18385     } catch (...) {
18386       {
18387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18388       };
18389     }
18390   }
18391
18392   jresult = (void *)result;
18393   return jresult;
18394 }
18395
18396
18397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18398   void * jresult ;
18399   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18400   Dali::BaseHandle *arg2 = 0 ;
18401   Dali::BaseHandle *result = 0 ;
18402
18403   arg1 = (Dali::BaseHandle *)jarg1;
18404   arg2 = (Dali::BaseHandle *)jarg2;
18405   if (!arg2) {
18406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18407     return 0;
18408   }
18409   {
18410     try {
18411       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18412     } catch (std::out_of_range& e) {
18413       {
18414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18415       };
18416     } catch (std::exception& e) {
18417       {
18418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18419       };
18420     } catch (Dali::DaliException e) {
18421       {
18422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18423       };
18424     } catch (...) {
18425       {
18426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18427       };
18428     }
18429   }
18430
18431   jresult = (void *)result;
18432   return jresult;
18433 }
18434
18435
18436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18437   unsigned int jresult ;
18438   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18439   std::string *arg2 = 0 ;
18440   Dali::Property::Map *arg3 = 0 ;
18441   bool result;
18442
18443   arg1 = (Dali::BaseHandle *)jarg1;
18444   if (!jarg2) {
18445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18446     return 0;
18447   }
18448   std::string arg2_str(jarg2);
18449   arg2 = &arg2_str;
18450   arg3 = (Dali::Property::Map *)jarg3;
18451   if (!arg3) {
18452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18453     return 0;
18454   }
18455   {
18456     try {
18457       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18458     } catch (std::out_of_range& e) {
18459       {
18460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18461       };
18462     } catch (std::exception& e) {
18463       {
18464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18465       };
18466     } catch (Dali::DaliException e) {
18467       {
18468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18469       };
18470     } catch (...) {
18471       {
18472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18473       };
18474     }
18475   }
18476
18477   jresult = result;
18478
18479   //argout typemap for const std::string&
18480
18481   return jresult;
18482 }
18483
18484
18485 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18486   char * jresult ;
18487   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18488   std::string *result = 0 ;
18489
18490   arg1 = (Dali::BaseHandle *)jarg1;
18491   {
18492     try {
18493       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18494     } catch (std::out_of_range& e) {
18495       {
18496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18497       };
18498     } catch (std::exception& e) {
18499       {
18500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18501       };
18502     } catch (Dali::DaliException e) {
18503       {
18504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18505       };
18506     } catch (...) {
18507       {
18508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18509       };
18510     }
18511   }
18512
18513   jresult = SWIG_csharp_string_callback(result->c_str());
18514   return jresult;
18515 }
18516
18517
18518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18519   unsigned int jresult ;
18520   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18521   Dali::TypeInfo *arg2 = 0 ;
18522   bool result;
18523
18524   arg1 = (Dali::BaseHandle *)jarg1;
18525   arg2 = (Dali::TypeInfo *)jarg2;
18526   if (!arg2) {
18527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18528     return 0;
18529   }
18530   {
18531     try {
18532       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18533     } catch (std::out_of_range& e) {
18534       {
18535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18536       };
18537     } catch (std::exception& e) {
18538       {
18539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18540       };
18541     } catch (Dali::DaliException e) {
18542       {
18543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18544       };
18545     } catch (...) {
18546       {
18547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18548       };
18549     }
18550   }
18551
18552   jresult = result;
18553   return jresult;
18554 }
18555
18556
18557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18558   void * jresult ;
18559   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18560   Dali::BaseObject *result = 0 ;
18561
18562   arg1 = (Dali::BaseHandle *)jarg1;
18563   {
18564     try {
18565       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18566     } catch (std::out_of_range& e) {
18567       {
18568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18569       };
18570     } catch (std::exception& e) {
18571       {
18572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18573       };
18574     } catch (Dali::DaliException e) {
18575       {
18576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18577       };
18578     } catch (...) {
18579       {
18580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18581       };
18582     }
18583   }
18584
18585   jresult = (void *)result;
18586   return jresult;
18587 }
18588
18589
18590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18591   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18592
18593   arg1 = (Dali::BaseHandle *)jarg1;
18594   {
18595     try {
18596       (arg1)->Reset();
18597     } catch (std::out_of_range& e) {
18598       {
18599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18600       };
18601     } catch (std::exception& e) {
18602       {
18603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18604       };
18605     } catch (Dali::DaliException e) {
18606       {
18607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18608       };
18609     } catch (...) {
18610       {
18611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18612       };
18613     }
18614   }
18615
18616 }
18617
18618
18619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18620   unsigned int jresult ;
18621   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18622   Dali::BaseHandle *arg2 = 0 ;
18623   bool result;
18624
18625   arg1 = (Dali::BaseHandle *)jarg1;
18626   arg2 = (Dali::BaseHandle *)jarg2;
18627   if (!arg2) {
18628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18629     return 0;
18630   }
18631   {
18632     try {
18633       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18634     } catch (std::out_of_range& e) {
18635       {
18636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18637       };
18638     } catch (std::exception& e) {
18639       {
18640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18641       };
18642     } catch (Dali::DaliException e) {
18643       {
18644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18645       };
18646     } catch (...) {
18647       {
18648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18649       };
18650     }
18651   }
18652
18653   jresult = result;
18654   return jresult;
18655 }
18656
18657
18658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18659   unsigned int jresult ;
18660   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18661   Dali::BaseHandle *arg2 = 0 ;
18662   bool result;
18663
18664   arg1 = (Dali::BaseHandle *)jarg1;
18665   arg2 = (Dali::BaseHandle *)jarg2;
18666   if (!arg2) {
18667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18668     return 0;
18669   }
18670   {
18671     try {
18672       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18673     } catch (std::out_of_range& e) {
18674       {
18675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (std::exception& e) {
18678       {
18679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18680       };
18681     } catch (Dali::DaliException e) {
18682       {
18683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18684       };
18685     } catch (...) {
18686       {
18687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18688       };
18689     }
18690   }
18691
18692   jresult = result;
18693   return jresult;
18694 }
18695
18696
18697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18698   void * jresult ;
18699   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18700   Dali::RefObject *result = 0 ;
18701
18702   arg1 = (Dali::BaseHandle *)jarg1;
18703   {
18704     try {
18705       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18706     } catch (std::out_of_range& e) {
18707       {
18708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18709       };
18710     } catch (std::exception& e) {
18711       {
18712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18713       };
18714     } catch (Dali::DaliException e) {
18715       {
18716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18717       };
18718     } catch (...) {
18719       {
18720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18721       };
18722     }
18723   }
18724
18725   jresult = (void *)result;
18726   return jresult;
18727 }
18728
18729
18730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18731   unsigned int jresult ;
18732   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18733   bool result;
18734
18735   arg1 = (Dali::BaseHandle *)jarg1;
18736   {
18737     try {
18738       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18739     } catch (std::out_of_range& e) {
18740       {
18741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18742       };
18743     } catch (std::exception& e) {
18744       {
18745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18746       };
18747     } catch (Dali::DaliException e) {
18748       {
18749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18750       };
18751     } catch (...) {
18752       {
18753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18754       };
18755     }
18756   }
18757
18758   jresult = result;
18759   return jresult;
18760 }
18761
18762
18763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18764   unsigned int jresult ;
18765   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18766   Dali::BaseHandle *arg2 = 0 ;
18767   bool result;
18768
18769   arg1 = (Dali::BaseHandle *)jarg1;
18770   arg2 = (Dali::BaseHandle *)jarg2;
18771   if (!arg2) {
18772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18773     return 0;
18774   }
18775   {
18776     try {
18777       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18778     } catch (std::out_of_range& e) {
18779       {
18780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18781       };
18782     } catch (std::exception& e) {
18783       {
18784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18785       };
18786     } catch (Dali::DaliException e) {
18787       {
18788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18789       };
18790     } catch (...) {
18791       {
18792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18793       };
18794     }
18795   }
18796
18797   jresult = result;
18798   return jresult;
18799 }
18800
18801
18802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18803   unsigned int jresult ;
18804   Dali::BaseHandle *arg1 = 0 ;
18805   Dali::BaseHandle *arg2 = 0 ;
18806   bool result;
18807
18808   arg1 = (Dali::BaseHandle *)jarg1;
18809   if (!arg1) {
18810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18811     return 0;
18812   }
18813   arg2 = (Dali::BaseHandle *)jarg2;
18814   if (!arg2) {
18815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18816     return 0;
18817   }
18818   {
18819     try {
18820       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18821     } catch (std::out_of_range& e) {
18822       {
18823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18824       };
18825     } catch (std::exception& e) {
18826       {
18827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18828       };
18829     } catch (Dali::DaliException e) {
18830       {
18831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18832       };
18833     } catch (...) {
18834       {
18835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18836       };
18837     }
18838   }
18839
18840   jresult = result;
18841   return jresult;
18842 }
18843
18844
18845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18846   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18847
18848   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18849   {
18850     try {
18851       delete arg1;
18852     } catch (std::out_of_range& e) {
18853       {
18854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18855       };
18856     } catch (std::exception& e) {
18857       {
18858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18859       };
18860     } catch (Dali::DaliException e) {
18861       {
18862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18863       };
18864     } catch (...) {
18865       {
18866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18867       };
18868     }
18869   }
18870
18871 }
18872
18873
18874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18875   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18876   SlotObserver *arg2 = (SlotObserver *) 0 ;
18877   CallbackBase *arg3 = (CallbackBase *) 0 ;
18878
18879   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18880   arg2 = (SlotObserver *)jarg2;
18881   arg3 = (CallbackBase *)jarg3;
18882   {
18883     try {
18884       (arg1)->SignalConnected(arg2,arg3);
18885     } catch (std::out_of_range& e) {
18886       {
18887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18888       };
18889     } catch (std::exception& e) {
18890       {
18891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18892       };
18893     } catch (Dali::DaliException e) {
18894       {
18895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18896       };
18897     } catch (...) {
18898       {
18899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18900       };
18901     }
18902   }
18903
18904 }
18905
18906
18907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18908   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18909
18910   arg1 = (Dali::SignalObserver *)jarg1;
18911   {
18912     try {
18913       delete arg1;
18914     } catch (std::out_of_range& e) {
18915       {
18916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18917       };
18918     } catch (std::exception& e) {
18919       {
18920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18921       };
18922     } catch (Dali::DaliException e) {
18923       {
18924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18925       };
18926     } catch (...) {
18927       {
18928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18929       };
18930     }
18931   }
18932
18933 }
18934
18935
18936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18937   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18938   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18939   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18940
18941   arg1 = (Dali::SignalObserver *)jarg1;
18942   arg2 = (Dali::SlotObserver *)jarg2;
18943   arg3 = (Dali::CallbackBase *)jarg3;
18944   {
18945     try {
18946       (arg1)->SignalDisconnected(arg2,arg3);
18947     } catch (std::out_of_range& e) {
18948       {
18949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18950       };
18951     } catch (std::exception& e) {
18952       {
18953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18954       };
18955     } catch (Dali::DaliException e) {
18956       {
18957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18958       };
18959     } catch (...) {
18960       {
18961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18962       };
18963     }
18964   }
18965
18966 }
18967
18968
18969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18970   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18971
18972   arg1 = (Dali::SlotObserver *)jarg1;
18973   {
18974     try {
18975       delete arg1;
18976     } catch (std::out_of_range& e) {
18977       {
18978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18979       };
18980     } catch (std::exception& e) {
18981       {
18982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18983       };
18984     } catch (Dali::DaliException e) {
18985       {
18986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18987       };
18988     } catch (...) {
18989       {
18990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18991       };
18992     }
18993   }
18994
18995 }
18996
18997
18998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18999   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19000   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19001
19002   arg1 = (Dali::SlotObserver *)jarg1;
19003   arg2 = (Dali::CallbackBase *)jarg2;
19004   {
19005     try {
19006       (arg1)->SlotDisconnected(arg2);
19007     } catch (std::out_of_range& e) {
19008       {
19009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19010       };
19011     } catch (std::exception& e) {
19012       {
19013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19014       };
19015     } catch (Dali::DaliException e) {
19016       {
19017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19018       };
19019     } catch (...) {
19020       {
19021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19022       };
19023     }
19024   }
19025
19026 }
19027
19028
19029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19030   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19031
19032   arg1 = (Dali::ConnectionTracker *)jarg1;
19033   {
19034     try {
19035       delete arg1;
19036     } catch (std::out_of_range& e) {
19037       {
19038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19039       };
19040     } catch (std::exception& e) {
19041       {
19042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19043       };
19044     } catch (Dali::DaliException e) {
19045       {
19046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19047       };
19048     } catch (...) {
19049       {
19050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19051       };
19052     }
19053   }
19054
19055 }
19056
19057
19058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19059   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19060
19061   arg1 = (Dali::ConnectionTracker *)jarg1;
19062   {
19063     try {
19064       (arg1)->DisconnectAll();
19065     } catch (std::out_of_range& e) {
19066       {
19067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19068       };
19069     } catch (std::exception& e) {
19070       {
19071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19072       };
19073     } catch (Dali::DaliException e) {
19074       {
19075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19076       };
19077     } catch (...) {
19078       {
19079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19080       };
19081     }
19082   }
19083
19084 }
19085
19086
19087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19088   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19089   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19090   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19091
19092   arg1 = (Dali::ConnectionTracker *)jarg1;
19093   arg2 = (Dali::SlotObserver *)jarg2;
19094   arg3 = (Dali::CallbackBase *)jarg3;
19095   {
19096     try {
19097       (arg1)->SignalConnected(arg2,arg3);
19098     } catch (std::out_of_range& e) {
19099       {
19100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19101       };
19102     } catch (std::exception& e) {
19103       {
19104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19105       };
19106     } catch (Dali::DaliException e) {
19107       {
19108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19109       };
19110     } catch (...) {
19111       {
19112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19113       };
19114     }
19115   }
19116
19117 }
19118
19119
19120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19121   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19122   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19123   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19124
19125   arg1 = (Dali::ConnectionTracker *)jarg1;
19126   arg2 = (Dali::SlotObserver *)jarg2;
19127   arg3 = (Dali::CallbackBase *)jarg3;
19128   {
19129     try {
19130       (arg1)->SignalDisconnected(arg2,arg3);
19131     } catch (std::out_of_range& e) {
19132       {
19133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19134       };
19135     } catch (std::exception& e) {
19136       {
19137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19138       };
19139     } catch (Dali::DaliException e) {
19140       {
19141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19142       };
19143     } catch (...) {
19144       {
19145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19146       };
19147     }
19148   }
19149
19150 }
19151
19152
19153 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19154   unsigned long jresult ;
19155   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19156   std::size_t result;
19157
19158   arg1 = (Dali::ConnectionTracker *)jarg1;
19159   {
19160     try {
19161       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19162     } catch (std::out_of_range& e) {
19163       {
19164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19165       };
19166     } catch (std::exception& e) {
19167       {
19168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19169       };
19170     } catch (Dali::DaliException e) {
19171       {
19172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19173       };
19174     } catch (...) {
19175       {
19176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19177       };
19178     }
19179   }
19180
19181   jresult = (unsigned long)result;
19182   return jresult;
19183 }
19184
19185
19186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19187   void * jresult ;
19188   Dali::ObjectRegistry *result = 0 ;
19189
19190   {
19191     try {
19192       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19193     } catch (std::out_of_range& e) {
19194       {
19195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19196       };
19197     } catch (std::exception& e) {
19198       {
19199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19200       };
19201     } catch (Dali::DaliException e) {
19202       {
19203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19204       };
19205     } catch (...) {
19206       {
19207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19208       };
19209     }
19210   }
19211
19212   jresult = (void *)result;
19213   return jresult;
19214 }
19215
19216
19217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19218   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19219
19220   arg1 = (Dali::ObjectRegistry *)jarg1;
19221   {
19222     try {
19223       delete arg1;
19224     } catch (std::out_of_range& e) {
19225       {
19226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19227       };
19228     } catch (std::exception& e) {
19229       {
19230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19231       };
19232     } catch (Dali::DaliException e) {
19233       {
19234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19235       };
19236     } catch (...) {
19237       {
19238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19239       };
19240     }
19241   }
19242
19243 }
19244
19245
19246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19247   void * jresult ;
19248   Dali::ObjectRegistry *arg1 = 0 ;
19249   Dali::ObjectRegistry *result = 0 ;
19250
19251   arg1 = (Dali::ObjectRegistry *)jarg1;
19252   if (!arg1) {
19253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19254     return 0;
19255   }
19256   {
19257     try {
19258       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19259     } catch (std::out_of_range& e) {
19260       {
19261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19262       };
19263     } catch (std::exception& e) {
19264       {
19265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19266       };
19267     } catch (Dali::DaliException e) {
19268       {
19269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19270       };
19271     } catch (...) {
19272       {
19273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19274       };
19275     }
19276   }
19277
19278   jresult = (void *)result;
19279   return jresult;
19280 }
19281
19282
19283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19284   void * jresult ;
19285   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19286   Dali::ObjectRegistry *arg2 = 0 ;
19287   Dali::ObjectRegistry *result = 0 ;
19288
19289   arg1 = (Dali::ObjectRegistry *)jarg1;
19290   arg2 = (Dali::ObjectRegistry *)jarg2;
19291   if (!arg2) {
19292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19293     return 0;
19294   }
19295   {
19296     try {
19297       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19298     } catch (std::out_of_range& e) {
19299       {
19300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19301       };
19302     } catch (std::exception& e) {
19303       {
19304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19305       };
19306     } catch (Dali::DaliException e) {
19307       {
19308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19309       };
19310     } catch (...) {
19311       {
19312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19313       };
19314     }
19315   }
19316
19317   jresult = (void *)result;
19318   return jresult;
19319 }
19320
19321
19322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19323   void * jresult ;
19324   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19325   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19326
19327   arg1 = (Dali::ObjectRegistry *)jarg1;
19328   {
19329     try {
19330       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19331     } catch (std::out_of_range& e) {
19332       {
19333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19334       };
19335     } catch (std::exception& e) {
19336       {
19337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19338       };
19339     } catch (Dali::DaliException e) {
19340       {
19341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19342       };
19343     } catch (...) {
19344       {
19345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19346       };
19347     }
19348   }
19349
19350   jresult = (void *)result;
19351   return jresult;
19352 }
19353
19354
19355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19356   void * jresult ;
19357   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19358   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19359
19360   arg1 = (Dali::ObjectRegistry *)jarg1;
19361   {
19362     try {
19363       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19364     } catch (std::out_of_range& e) {
19365       {
19366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19367       };
19368     } catch (std::exception& e) {
19369       {
19370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19371       };
19372     } catch (Dali::DaliException e) {
19373       {
19374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19375       };
19376     } catch (...) {
19377       {
19378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19379       };
19380     }
19381   }
19382
19383   jresult = (void *)result;
19384   return jresult;
19385 }
19386
19387
19388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19389   void * jresult ;
19390   Dali::PropertyCondition *result = 0 ;
19391
19392   {
19393     try {
19394       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19395     } catch (std::out_of_range& e) {
19396       {
19397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19398       };
19399     } catch (std::exception& e) {
19400       {
19401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19402       };
19403     } catch (Dali::DaliException e) {
19404       {
19405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19406       };
19407     } catch (...) {
19408       {
19409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19410       };
19411     }
19412   }
19413
19414   jresult = (void *)result;
19415   return jresult;
19416 }
19417
19418
19419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19420   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19421
19422   arg1 = (Dali::PropertyCondition *)jarg1;
19423   {
19424     try {
19425       delete arg1;
19426     } catch (std::out_of_range& e) {
19427       {
19428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19429       };
19430     } catch (std::exception& e) {
19431       {
19432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19433       };
19434     } catch (Dali::DaliException e) {
19435       {
19436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19437       };
19438     } catch (...) {
19439       {
19440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19441       };
19442     }
19443   }
19444
19445 }
19446
19447
19448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19449   void * jresult ;
19450   Dali::PropertyCondition *arg1 = 0 ;
19451   Dali::PropertyCondition *result = 0 ;
19452
19453   arg1 = (Dali::PropertyCondition *)jarg1;
19454   if (!arg1) {
19455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19456     return 0;
19457   }
19458   {
19459     try {
19460       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19461     } catch (std::out_of_range& e) {
19462       {
19463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19464       };
19465     } catch (std::exception& e) {
19466       {
19467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19468       };
19469     } catch (Dali::DaliException e) {
19470       {
19471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19472       };
19473     } catch (...) {
19474       {
19475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19476       };
19477     }
19478   }
19479
19480   jresult = (void *)result;
19481   return jresult;
19482 }
19483
19484
19485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19486   void * jresult ;
19487   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19488   Dali::PropertyCondition *arg2 = 0 ;
19489   Dali::PropertyCondition *result = 0 ;
19490
19491   arg1 = (Dali::PropertyCondition *)jarg1;
19492   arg2 = (Dali::PropertyCondition *)jarg2;
19493   if (!arg2) {
19494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19495     return 0;
19496   }
19497   {
19498     try {
19499       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19500     } catch (std::out_of_range& e) {
19501       {
19502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19503       };
19504     } catch (std::exception& e) {
19505       {
19506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19507       };
19508     } catch (Dali::DaliException e) {
19509       {
19510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19511       };
19512     } catch (...) {
19513       {
19514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19515       };
19516     }
19517   }
19518
19519   jresult = (void *)result;
19520   return jresult;
19521 }
19522
19523
19524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19525   unsigned long jresult ;
19526   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19527   std::size_t result;
19528
19529   arg1 = (Dali::PropertyCondition *)jarg1;
19530   {
19531     try {
19532       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19533     } catch (std::out_of_range& e) {
19534       {
19535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19536       };
19537     } catch (std::exception& e) {
19538       {
19539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19540       };
19541     } catch (...) {
19542       {
19543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19544       };
19545     }
19546   }
19547   jresult = (unsigned long)result;
19548   return jresult;
19549 }
19550
19551
19552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19553   float jresult ;
19554   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19555   std::size_t arg2 ;
19556   float result;
19557
19558   arg1 = (Dali::PropertyCondition *)jarg1;
19559   arg2 = (std::size_t)jarg2;
19560   {
19561     try {
19562       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19563     } catch (std::out_of_range& e) {
19564       {
19565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19566       };
19567     } catch (std::exception& e) {
19568       {
19569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19570       };
19571     } catch (...) {
19572       {
19573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19574       };
19575     }
19576   }
19577   jresult = result;
19578   return jresult;
19579 }
19580
19581
19582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19583   void * jresult ;
19584   float arg1 ;
19585   Dali::PropertyCondition result;
19586
19587   arg1 = (float)jarg1;
19588   {
19589     try {
19590       result = Dali::LessThanCondition(arg1);
19591     } catch (std::out_of_range& e) {
19592       {
19593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19594       };
19595     } catch (std::exception& e) {
19596       {
19597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19598       };
19599     } catch (Dali::DaliException e) {
19600       {
19601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19602       };
19603     } catch (...) {
19604       {
19605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19606       };
19607     }
19608   }
19609
19610   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19611   return jresult;
19612 }
19613
19614
19615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19616   void * jresult ;
19617   float arg1 ;
19618   Dali::PropertyCondition result;
19619
19620   arg1 = (float)jarg1;
19621   {
19622     try {
19623       result = Dali::GreaterThanCondition(arg1);
19624     } catch (std::out_of_range& e) {
19625       {
19626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19627       };
19628     } catch (std::exception& e) {
19629       {
19630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19631       };
19632     } catch (Dali::DaliException e) {
19633       {
19634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19635       };
19636     } catch (...) {
19637       {
19638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19639       };
19640     }
19641   }
19642
19643   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19644   return jresult;
19645 }
19646
19647
19648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19649   void * jresult ;
19650   float arg1 ;
19651   float arg2 ;
19652   Dali::PropertyCondition result;
19653
19654   arg1 = (float)jarg1;
19655   arg2 = (float)jarg2;
19656   {
19657     try {
19658       result = Dali::InsideCondition(arg1,arg2);
19659     } catch (std::out_of_range& e) {
19660       {
19661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (std::exception& e) {
19664       {
19665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19666       };
19667     } catch (Dali::DaliException e) {
19668       {
19669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19670       };
19671     } catch (...) {
19672       {
19673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19674       };
19675     }
19676   }
19677
19678   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19679   return jresult;
19680 }
19681
19682
19683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19684   void * jresult ;
19685   float arg1 ;
19686   float arg2 ;
19687   Dali::PropertyCondition result;
19688
19689   arg1 = (float)jarg1;
19690   arg2 = (float)jarg2;
19691   {
19692     try {
19693       result = Dali::OutsideCondition(arg1,arg2);
19694     } catch (std::out_of_range& e) {
19695       {
19696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19697       };
19698     } catch (std::exception& e) {
19699       {
19700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19701       };
19702     } catch (Dali::DaliException e) {
19703       {
19704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19705       };
19706     } catch (...) {
19707       {
19708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19709       };
19710     }
19711   }
19712
19713   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19714   return jresult;
19715 }
19716
19717
19718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19719   void * jresult ;
19720   float arg1 ;
19721   float arg2 ;
19722   Dali::PropertyCondition result;
19723
19724   arg1 = (float)jarg1;
19725   arg2 = (float)jarg2;
19726   {
19727     try {
19728       result = Dali::StepCondition(arg1,arg2);
19729     } catch (std::out_of_range& e) {
19730       {
19731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19732       };
19733     } catch (std::exception& e) {
19734       {
19735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19736       };
19737     } catch (Dali::DaliException e) {
19738       {
19739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19740       };
19741     } catch (...) {
19742       {
19743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19744       };
19745     }
19746   }
19747
19748   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19749   return jresult;
19750 }
19751
19752
19753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19754   void * jresult ;
19755   float arg1 ;
19756   Dali::PropertyCondition result;
19757
19758   arg1 = (float)jarg1;
19759   {
19760     try {
19761       result = Dali::StepCondition(arg1);
19762     } catch (std::out_of_range& e) {
19763       {
19764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19765       };
19766     } catch (std::exception& e) {
19767       {
19768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19769       };
19770     } catch (Dali::DaliException e) {
19771       {
19772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19773       };
19774     } catch (...) {
19775       {
19776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19777       };
19778     }
19779   }
19780
19781   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19782   return jresult;
19783 }
19784
19785
19786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19787   void * jresult ;
19788   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19789   Dali::PropertyCondition result;
19790
19791   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19792   if (!arg1) {
19793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19794     return 0;
19795   }
19796   {
19797     try {
19798       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19799     } catch (std::out_of_range& e) {
19800       {
19801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19802       };
19803     } catch (std::exception& e) {
19804       {
19805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19806       };
19807     } catch (Dali::DaliException e) {
19808       {
19809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19810       };
19811     } catch (...) {
19812       {
19813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19814       };
19815     }
19816   }
19817
19818   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19819   return jresult;
19820 }
19821
19822
19823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19824   void * jresult ;
19825   Dali::PropertyNotification *result = 0 ;
19826
19827   {
19828     try {
19829       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19830     } catch (std::out_of_range& e) {
19831       {
19832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19833       };
19834     } catch (std::exception& e) {
19835       {
19836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19837       };
19838     } catch (Dali::DaliException e) {
19839       {
19840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19841       };
19842     } catch (...) {
19843       {
19844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19845       };
19846     }
19847   }
19848
19849   jresult = (void *)result;
19850   return jresult;
19851 }
19852
19853
19854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19855   void * jresult ;
19856   Dali::BaseHandle arg1 ;
19857   Dali::BaseHandle *argp1 ;
19858   Dali::PropertyNotification result;
19859
19860   argp1 = (Dali::BaseHandle *)jarg1;
19861   if (!argp1) {
19862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19863     return 0;
19864   }
19865   arg1 = *argp1;
19866   {
19867     try {
19868       result = Dali::PropertyNotification::DownCast(arg1);
19869     } catch (std::out_of_range& e) {
19870       {
19871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (std::exception& e) {
19874       {
19875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19876       };
19877     } catch (Dali::DaliException e) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19880       };
19881     } catch (...) {
19882       {
19883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19884       };
19885     }
19886   }
19887
19888   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19889   return jresult;
19890 }
19891
19892
19893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19894   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19895
19896   arg1 = (Dali::PropertyNotification *)jarg1;
19897   {
19898     try {
19899       delete arg1;
19900     } catch (std::out_of_range& e) {
19901       {
19902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19903       };
19904     } catch (std::exception& e) {
19905       {
19906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19907       };
19908     } catch (Dali::DaliException e) {
19909       {
19910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19911       };
19912     } catch (...) {
19913       {
19914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19915       };
19916     }
19917   }
19918
19919 }
19920
19921
19922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19923   void * jresult ;
19924   Dali::PropertyNotification *arg1 = 0 ;
19925   Dali::PropertyNotification *result = 0 ;
19926
19927   arg1 = (Dali::PropertyNotification *)jarg1;
19928   if (!arg1) {
19929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19930     return 0;
19931   }
19932   {
19933     try {
19934       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19935     } catch (std::out_of_range& e) {
19936       {
19937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19938       };
19939     } catch (std::exception& e) {
19940       {
19941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19942       };
19943     } catch (Dali::DaliException e) {
19944       {
19945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19946       };
19947     } catch (...) {
19948       {
19949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19950       };
19951     }
19952   }
19953
19954   jresult = (void *)result;
19955   return jresult;
19956 }
19957
19958
19959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19960   void * jresult ;
19961   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19962   Dali::PropertyNotification *arg2 = 0 ;
19963   Dali::PropertyNotification *result = 0 ;
19964
19965   arg1 = (Dali::PropertyNotification *)jarg1;
19966   arg2 = (Dali::PropertyNotification *)jarg2;
19967   if (!arg2) {
19968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19969     return 0;
19970   }
19971   {
19972     try {
19973       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19974     } catch (std::out_of_range& e) {
19975       {
19976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19977       };
19978     } catch (std::exception& e) {
19979       {
19980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19981       };
19982     } catch (Dali::DaliException e) {
19983       {
19984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19985       };
19986     } catch (...) {
19987       {
19988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19989       };
19990     }
19991   }
19992
19993   jresult = (void *)result;
19994   return jresult;
19995 }
19996
19997
19998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19999   void * jresult ;
20000   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20001   Dali::PropertyCondition result;
20002
20003   arg1 = (Dali::PropertyNotification *)jarg1;
20004   {
20005     try {
20006       result = (arg1)->GetCondition();
20007     } catch (std::out_of_range& e) {
20008       {
20009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20010       };
20011     } catch (std::exception& e) {
20012       {
20013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20014       };
20015     } catch (Dali::DaliException e) {
20016       {
20017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20018       };
20019     } catch (...) {
20020       {
20021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20022       };
20023     }
20024   }
20025
20026   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20027   return jresult;
20028 }
20029
20030
20031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20032   void * jresult ;
20033   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20034   Dali::Handle result;
20035
20036   arg1 = (Dali::PropertyNotification *)jarg1;
20037   {
20038     try {
20039       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20040     } catch (std::out_of_range& e) {
20041       {
20042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20043       };
20044     } catch (std::exception& e) {
20045       {
20046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20047       };
20048     } catch (Dali::DaliException e) {
20049       {
20050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20051       };
20052     } catch (...) {
20053       {
20054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20055       };
20056     }
20057   }
20058
20059   jresult = new Dali::Handle((const Dali::Handle &)result);
20060   return jresult;
20061 }
20062
20063
20064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20065   int jresult ;
20066   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20067   Dali::Property::Index result;
20068
20069   arg1 = (Dali::PropertyNotification *)jarg1;
20070   {
20071     try {
20072       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20073     } catch (std::out_of_range& e) {
20074       {
20075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20076       };
20077     } catch (std::exception& e) {
20078       {
20079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20080       };
20081     } catch (Dali::DaliException e) {
20082       {
20083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20084       };
20085     } catch (...) {
20086       {
20087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20088       };
20089     }
20090   }
20091
20092   jresult = result;
20093   return jresult;
20094 }
20095
20096
20097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20098   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20099   Dali::PropertyNotification::NotifyMode arg2 ;
20100
20101   arg1 = (Dali::PropertyNotification *)jarg1;
20102   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20103   {
20104     try {
20105       (arg1)->SetNotifyMode(arg2);
20106     } catch (std::out_of_range& e) {
20107       {
20108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20109       };
20110     } catch (std::exception& e) {
20111       {
20112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20113       };
20114     } catch (Dali::DaliException e) {
20115       {
20116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20117       };
20118     } catch (...) {
20119       {
20120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20121       };
20122     }
20123   }
20124
20125 }
20126
20127
20128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20129   int jresult ;
20130   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20131   Dali::PropertyNotification::NotifyMode result;
20132
20133   arg1 = (Dali::PropertyNotification *)jarg1;
20134   {
20135     try {
20136       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20137     } catch (std::out_of_range& e) {
20138       {
20139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20140       };
20141     } catch (std::exception& e) {
20142       {
20143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20144       };
20145     } catch (Dali::DaliException e) {
20146       {
20147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20148       };
20149     } catch (...) {
20150       {
20151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20152       };
20153     }
20154   }
20155
20156   jresult = (int)result;
20157   return jresult;
20158 }
20159
20160
20161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20162   unsigned int jresult ;
20163   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20164   bool result;
20165
20166   arg1 = (Dali::PropertyNotification *)jarg1;
20167   {
20168     try {
20169       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20170     } catch (std::out_of_range& e) {
20171       {
20172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20173       };
20174     } catch (std::exception& e) {
20175       {
20176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20177       };
20178     } catch (Dali::DaliException e) {
20179       {
20180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20181       };
20182     } catch (...) {
20183       {
20184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20185       };
20186     }
20187   }
20188
20189   jresult = result;
20190   return jresult;
20191 }
20192
20193
20194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20195   void * jresult ;
20196   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20197   Dali::PropertyNotifySignalType *result = 0 ;
20198
20199   arg1 = (Dali::PropertyNotification *)jarg1;
20200   {
20201     try {
20202       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20203     } catch (std::out_of_range& e) {
20204       {
20205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20206       };
20207     } catch (std::exception& e) {
20208       {
20209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20210       };
20211     } catch (Dali::DaliException e) {
20212       {
20213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20214       };
20215     } catch (...) {
20216       {
20217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20218       };
20219     }
20220   }
20221
20222   jresult = (void *)result;
20223   return jresult;
20224 }
20225
20226
20227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20228   void * jresult ;
20229   Dali::Handle *result = 0 ;
20230
20231   {
20232     try {
20233       result = (Dali::Handle *)new Dali::Handle();
20234     } catch (std::out_of_range& e) {
20235       {
20236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20237       };
20238     } catch (std::exception& e) {
20239       {
20240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20241       };
20242     } catch (Dali::DaliException e) {
20243       {
20244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20245       };
20246     } catch (...) {
20247       {
20248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20249       };
20250     }
20251   }
20252
20253   jresult = (void *)result;
20254   return jresult;
20255 }
20256
20257
20258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20259   void * jresult ;
20260   Dali::Handle result;
20261
20262   {
20263     try {
20264       result = Dali::Handle::New();
20265     } catch (std::out_of_range& e) {
20266       {
20267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20268       };
20269     } catch (std::exception& e) {
20270       {
20271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20272       };
20273     } catch (Dali::DaliException e) {
20274       {
20275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20276       };
20277     } catch (...) {
20278       {
20279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20280       };
20281     }
20282   }
20283
20284   jresult = new Dali::Handle((const Dali::Handle &)result);
20285   return jresult;
20286 }
20287
20288
20289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20290   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20291
20292   arg1 = (Dali::Handle *)jarg1;
20293   {
20294     try {
20295       delete arg1;
20296     } catch (std::out_of_range& e) {
20297       {
20298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20299       };
20300     } catch (std::exception& e) {
20301       {
20302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20303       };
20304     } catch (Dali::DaliException e) {
20305       {
20306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20307       };
20308     } catch (...) {
20309       {
20310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20311       };
20312     }
20313   }
20314
20315 }
20316
20317
20318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20319   void * jresult ;
20320   Dali::Handle *arg1 = 0 ;
20321   Dali::Handle *result = 0 ;
20322
20323   arg1 = (Dali::Handle *)jarg1;
20324   if (!arg1) {
20325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20326     return 0;
20327   }
20328   {
20329     try {
20330       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20331     } catch (std::out_of_range& e) {
20332       {
20333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20334       };
20335     } catch (std::exception& e) {
20336       {
20337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20338       };
20339     } catch (Dali::DaliException e) {
20340       {
20341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20342       };
20343     } catch (...) {
20344       {
20345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20346       };
20347     }
20348   }
20349
20350   jresult = (void *)result;
20351   return jresult;
20352 }
20353
20354
20355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20356   void * jresult ;
20357   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20358   Dali::Handle *arg2 = 0 ;
20359   Dali::Handle *result = 0 ;
20360
20361   arg1 = (Dali::Handle *)jarg1;
20362   arg2 = (Dali::Handle *)jarg2;
20363   if (!arg2) {
20364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20365     return 0;
20366   }
20367   {
20368     try {
20369       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20370     } catch (std::out_of_range& e) {
20371       {
20372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20373       };
20374     } catch (std::exception& e) {
20375       {
20376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20377       };
20378     } catch (Dali::DaliException e) {
20379       {
20380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20381       };
20382     } catch (...) {
20383       {
20384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20385       };
20386     }
20387   }
20388
20389   jresult = (void *)result;
20390   return jresult;
20391 }
20392
20393
20394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20395   void * jresult ;
20396   Dali::BaseHandle arg1 ;
20397   Dali::BaseHandle *argp1 ;
20398   Dali::Handle result;
20399
20400   argp1 = (Dali::BaseHandle *)jarg1;
20401   if (!argp1) {
20402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20403     return 0;
20404   }
20405   arg1 = *argp1;
20406   {
20407     try {
20408       result = Dali::Handle::DownCast(arg1);
20409     } catch (std::out_of_range& e) {
20410       {
20411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20412       };
20413     } catch (std::exception& e) {
20414       {
20415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20416       };
20417     } catch (Dali::DaliException e) {
20418       {
20419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20420       };
20421     } catch (...) {
20422       {
20423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20424       };
20425     }
20426   }
20427
20428   jresult = new Dali::Handle((const Dali::Handle &)result);
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20434   unsigned int jresult ;
20435   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20436   Dali::Handle::Capability arg2 ;
20437   bool result;
20438
20439   arg1 = (Dali::Handle *)jarg1;
20440   arg2 = (Dali::Handle::Capability)jarg2;
20441   {
20442     try {
20443       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20444     } catch (std::out_of_range& e) {
20445       {
20446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20447       };
20448     } catch (std::exception& e) {
20449       {
20450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20451       };
20452     } catch (Dali::DaliException e) {
20453       {
20454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20455       };
20456     } catch (...) {
20457       {
20458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20459       };
20460     }
20461   }
20462
20463   jresult = result;
20464   return jresult;
20465 }
20466
20467
20468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20469   unsigned int jresult ;
20470   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20471   unsigned int result;
20472
20473   arg1 = (Dali::Handle *)jarg1;
20474   {
20475     try {
20476       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20477     } catch (std::out_of_range& e) {
20478       {
20479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20480       };
20481     } catch (std::exception& e) {
20482       {
20483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20484       };
20485     } catch (Dali::DaliException e) {
20486       {
20487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20488       };
20489     } catch (...) {
20490       {
20491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20492       };
20493     }
20494   }
20495
20496   jresult = result;
20497   return jresult;
20498 }
20499
20500
20501 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20502   char * jresult ;
20503   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20504   Dali::Property::Index arg2 ;
20505   std::string result;
20506
20507   arg1 = (Dali::Handle *)jarg1;
20508   arg2 = (Dali::Property::Index)jarg2;
20509   {
20510     try {
20511       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20512     } catch (std::out_of_range& e) {
20513       {
20514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20515       };
20516     } catch (std::exception& e) {
20517       {
20518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20519       };
20520     } catch (Dali::DaliException e) {
20521       {
20522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20523       };
20524     } catch (...) {
20525       {
20526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20527       };
20528     }
20529   }
20530
20531   jresult = SWIG_csharp_string_callback((&result)->c_str());
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20537   int jresult ;
20538   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20539   std::string *arg2 = 0 ;
20540   Dali::Property::Index result;
20541
20542   arg1 = (Dali::Handle *)jarg1;
20543   if (!jarg2) {
20544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20545     return 0;
20546   }
20547   std::string arg2_str(jarg2);
20548   arg2 = &arg2_str;
20549   {
20550     try {
20551       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20552     } catch (std::out_of_range& e) {
20553       {
20554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20555       };
20556     } catch (std::exception& e) {
20557       {
20558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20559       };
20560     } catch (Dali::DaliException e) {
20561       {
20562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20563       };
20564     } catch (...) {
20565       {
20566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20567       };
20568     }
20569   }
20570
20571   jresult = result;
20572
20573   //argout typemap for const std::string&
20574
20575   return jresult;
20576 }
20577
20578
20579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20580   unsigned int jresult ;
20581   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20582   Dali::Property::Index arg2 ;
20583   bool result;
20584
20585   arg1 = (Dali::Handle *)jarg1;
20586   arg2 = (Dali::Property::Index)jarg2;
20587   {
20588     try {
20589       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20590     } catch (std::out_of_range& e) {
20591       {
20592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20593       };
20594     } catch (std::exception& e) {
20595       {
20596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20597       };
20598     } catch (Dali::DaliException e) {
20599       {
20600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20601       };
20602     } catch (...) {
20603       {
20604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20605       };
20606     }
20607   }
20608
20609   jresult = result;
20610   return jresult;
20611 }
20612
20613
20614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20615   unsigned int jresult ;
20616   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20617   Dali::Property::Index arg2 ;
20618   bool result;
20619
20620   arg1 = (Dali::Handle *)jarg1;
20621   arg2 = (Dali::Property::Index)jarg2;
20622   {
20623     try {
20624       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20625     } catch (std::out_of_range& e) {
20626       {
20627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (std::exception& e) {
20630       {
20631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20632       };
20633     } catch (Dali::DaliException e) {
20634       {
20635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20636       };
20637     } catch (...) {
20638       {
20639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20640       };
20641     }
20642   }
20643
20644   jresult = result;
20645   return jresult;
20646 }
20647
20648
20649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20650   unsigned int jresult ;
20651   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20652   Dali::Property::Index arg2 ;
20653   bool result;
20654
20655   arg1 = (Dali::Handle *)jarg1;
20656   arg2 = (Dali::Property::Index)jarg2;
20657   {
20658     try {
20659       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20660     } catch (std::out_of_range& e) {
20661       {
20662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20663       };
20664     } catch (std::exception& e) {
20665       {
20666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20667       };
20668     } catch (Dali::DaliException e) {
20669       {
20670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20671       };
20672     } catch (...) {
20673       {
20674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20675       };
20676     }
20677   }
20678
20679   jresult = result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20685   int jresult ;
20686   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20687   Dali::Property::Index arg2 ;
20688   Dali::Property::Type result;
20689
20690   arg1 = (Dali::Handle *)jarg1;
20691   arg2 = (Dali::Property::Index)jarg2;
20692   {
20693     try {
20694       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20695     } catch (std::out_of_range& e) {
20696       {
20697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20698       };
20699     } catch (std::exception& e) {
20700       {
20701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20702       };
20703     } catch (Dali::DaliException e) {
20704       {
20705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20706       };
20707     } catch (...) {
20708       {
20709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20710       };
20711     }
20712   }
20713
20714   jresult = (int)result;
20715   return jresult;
20716 }
20717
20718
20719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20720   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20721   Dali::Property::Index arg2 ;
20722   Dali::Property::Value *arg3 = 0 ;
20723
20724   arg1 = (Dali::Handle *)jarg1;
20725   arg2 = (Dali::Property::Index)jarg2;
20726   arg3 = (Dali::Property::Value *)jarg3;
20727   if (!arg3) {
20728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20729     return ;
20730   }
20731   {
20732     try {
20733       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20734     } catch (std::out_of_range& e) {
20735       {
20736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20737       };
20738     } catch (std::exception& e) {
20739       {
20740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20741       };
20742     } catch (Dali::DaliException e) {
20743       {
20744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20745       };
20746     } catch (...) {
20747       {
20748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20749       };
20750     }
20751   }
20752
20753 }
20754
20755
20756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20757   int jresult ;
20758   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20759   std::string *arg2 = 0 ;
20760   Dali::Property::Value *arg3 = 0 ;
20761   Dali::Property::Index result;
20762
20763   arg1 = (Dali::Handle *)jarg1;
20764   if (!jarg2) {
20765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20766     return 0;
20767   }
20768   std::string arg2_str(jarg2);
20769   arg2 = &arg2_str;
20770   arg3 = (Dali::Property::Value *)jarg3;
20771   if (!arg3) {
20772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20773     return 0;
20774   }
20775   {
20776     try {
20777       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20778     } catch (std::out_of_range& e) {
20779       {
20780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20781       };
20782     } catch (std::exception& e) {
20783       {
20784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20785       };
20786     } catch (Dali::DaliException e) {
20787       {
20788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20789       };
20790     } catch (...) {
20791       {
20792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20793       };
20794     }
20795   }
20796
20797   jresult = result;
20798
20799   //argout typemap for const std::string&
20800
20801   return jresult;
20802 }
20803
20804
20805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20806   int jresult ;
20807   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20808   std::string *arg2 = 0 ;
20809   Dali::Property::Value *arg3 = 0 ;
20810   Dali::Property::AccessMode arg4 ;
20811   Dali::Property::Index result;
20812
20813   arg1 = (Dali::Handle *)jarg1;
20814   if (!jarg2) {
20815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20816     return 0;
20817   }
20818   std::string arg2_str(jarg2);
20819   arg2 = &arg2_str;
20820   arg3 = (Dali::Property::Value *)jarg3;
20821   if (!arg3) {
20822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20823     return 0;
20824   }
20825   arg4 = (Dali::Property::AccessMode)jarg4;
20826   {
20827     try {
20828       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20829     } catch (std::out_of_range& e) {
20830       {
20831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20832       };
20833     } catch (std::exception& e) {
20834       {
20835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20836       };
20837     } catch (Dali::DaliException e) {
20838       {
20839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20840       };
20841     } catch (...) {
20842       {
20843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20844       };
20845     }
20846   }
20847
20848   jresult = result;
20849
20850   //argout typemap for const std::string&
20851
20852   return jresult;
20853 }
20854
20855
20856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20857   void * jresult ;
20858   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20859   Dali::Property::Index arg2 ;
20860   Dali::Property::Value result;
20861
20862   arg1 = (Dali::Handle *)jarg1;
20863   arg2 = (Dali::Property::Index)jarg2;
20864   {
20865     try {
20866       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20867     } catch (std::out_of_range& e) {
20868       {
20869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20870       };
20871     } catch (std::exception& e) {
20872       {
20873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20874       };
20875     } catch (Dali::DaliException e) {
20876       {
20877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20878       };
20879     } catch (...) {
20880       {
20881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20882       };
20883     }
20884   }
20885
20886   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20887   return jresult;
20888 }
20889
20890
20891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20892   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20893   Dali::Property::IndexContainer *arg2 = 0 ;
20894
20895   arg1 = (Dali::Handle *)jarg1;
20896   arg2 = (Dali::Property::IndexContainer *)jarg2;
20897   if (!arg2) {
20898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20899     return ;
20900   }
20901   {
20902     try {
20903       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20904     } catch (std::out_of_range& e) {
20905       {
20906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20907       };
20908     } catch (std::exception& e) {
20909       {
20910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20911       };
20912     } catch (Dali::DaliException e) {
20913       {
20914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20915       };
20916     } catch (...) {
20917       {
20918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20919       };
20920     }
20921   }
20922
20923 }
20924
20925
20926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20927   void * jresult ;
20928   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20929   Dali::Property::Index arg2 ;
20930   Dali::PropertyCondition *arg3 = 0 ;
20931   Dali::PropertyNotification result;
20932
20933   arg1 = (Dali::Handle *)jarg1;
20934   arg2 = (Dali::Property::Index)jarg2;
20935   arg3 = (Dali::PropertyCondition *)jarg3;
20936   if (!arg3) {
20937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20938     return 0;
20939   }
20940   {
20941     try {
20942       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20943     } catch (std::out_of_range& e) {
20944       {
20945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20946       };
20947     } catch (std::exception& e) {
20948       {
20949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20950       };
20951     } catch (Dali::DaliException e) {
20952       {
20953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20954       };
20955     } catch (...) {
20956       {
20957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20958       };
20959     }
20960   }
20961
20962   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20963   return jresult;
20964 }
20965
20966
20967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20968   void * jresult ;
20969   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20970   Dali::Property::Index arg2 ;
20971   int arg3 ;
20972   Dali::PropertyCondition *arg4 = 0 ;
20973   Dali::PropertyNotification result;
20974
20975   arg1 = (Dali::Handle *)jarg1;
20976   arg2 = (Dali::Property::Index)jarg2;
20977   arg3 = (int)jarg3;
20978   arg4 = (Dali::PropertyCondition *)jarg4;
20979   if (!arg4) {
20980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20981     return 0;
20982   }
20983   {
20984     try {
20985       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20986     } catch (std::out_of_range& e) {
20987       {
20988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20989       };
20990     } catch (std::exception& e) {
20991       {
20992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20993       };
20994     } catch (Dali::DaliException e) {
20995       {
20996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20997       };
20998     } catch (...) {
20999       {
21000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21001       };
21002     }
21003   }
21004
21005   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21006   return jresult;
21007 }
21008
21009
21010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21011   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21012   Dali::PropertyNotification arg2 ;
21013   Dali::PropertyNotification *argp2 ;
21014
21015   arg1 = (Dali::Handle *)jarg1;
21016   argp2 = (Dali::PropertyNotification *)jarg2;
21017   if (!argp2) {
21018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21019     return ;
21020   }
21021   arg2 = *argp2;
21022   {
21023     try {
21024       (arg1)->RemovePropertyNotification(arg2);
21025     } catch (std::out_of_range& e) {
21026       {
21027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21028       };
21029     } catch (std::exception& e) {
21030       {
21031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21032       };
21033     } catch (Dali::DaliException e) {
21034       {
21035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21036       };
21037     } catch (...) {
21038       {
21039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21040       };
21041     }
21042   }
21043
21044 }
21045
21046
21047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21048   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21049
21050   arg1 = (Dali::Handle *)jarg1;
21051   {
21052     try {
21053       (arg1)->RemovePropertyNotifications();
21054     } catch (std::out_of_range& e) {
21055       {
21056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21057       };
21058     } catch (std::exception& e) {
21059       {
21060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21061       };
21062     } catch (Dali::DaliException e) {
21063       {
21064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21065       };
21066     } catch (...) {
21067       {
21068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21069       };
21070     }
21071   }
21072
21073 }
21074
21075
21076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21077   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21078
21079   arg1 = (Dali::Handle *)jarg1;
21080   {
21081     try {
21082       (arg1)->RemoveConstraints();
21083     } catch (std::out_of_range& e) {
21084       {
21085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21086       };
21087     } catch (std::exception& e) {
21088       {
21089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21090       };
21091     } catch (Dali::DaliException e) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21094       };
21095     } catch (...) {
21096       {
21097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21098       };
21099     }
21100   }
21101
21102 }
21103
21104
21105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21106   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21107   unsigned int arg2 ;
21108
21109   arg1 = (Dali::Handle *)jarg1;
21110   arg2 = (unsigned int)jarg2;
21111   {
21112     try {
21113       (arg1)->RemoveConstraints(arg2);
21114     } catch (std::out_of_range& e) {
21115       {
21116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21117       };
21118     } catch (std::exception& e) {
21119       {
21120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21121       };
21122     } catch (Dali::DaliException e) {
21123       {
21124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21125       };
21126     } catch (...) {
21127       {
21128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21129       };
21130     }
21131   }
21132
21133 }
21134
21135
21136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21137   int jresult ;
21138   Dali::Property::Index result;
21139
21140   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21141   jresult = result;
21142   return jresult;
21143 }
21144
21145
21146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21147   void * jresult ;
21148   Dali::Handle result;
21149
21150   {
21151     try {
21152       result = Dali::WeightObject::New();
21153     } catch (std::out_of_range& e) {
21154       {
21155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21156       };
21157     } catch (std::exception& e) {
21158       {
21159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21160       };
21161     } catch (Dali::DaliException e) {
21162       {
21163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21164       };
21165     } catch (...) {
21166       {
21167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21168       };
21169     }
21170   }
21171
21172   jresult = new Dali::Handle((const Dali::Handle &)result);
21173   return jresult;
21174 }
21175
21176
21177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21178   void * jresult ;
21179   Dali::TypeInfo *result = 0 ;
21180
21181   {
21182     try {
21183       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21184     } catch (std::out_of_range& e) {
21185       {
21186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21187       };
21188     } catch (std::exception& e) {
21189       {
21190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21191       };
21192     } catch (Dali::DaliException e) {
21193       {
21194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21195       };
21196     } catch (...) {
21197       {
21198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21199       };
21200     }
21201   }
21202
21203   jresult = (void *)result;
21204   return jresult;
21205 }
21206
21207
21208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21209   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21210
21211   arg1 = (Dali::TypeInfo *)jarg1;
21212   {
21213     try {
21214       delete arg1;
21215     } catch (std::out_of_range& e) {
21216       {
21217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21218       };
21219     } catch (std::exception& e) {
21220       {
21221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21222       };
21223     } catch (Dali::DaliException e) {
21224       {
21225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21226       };
21227     } catch (...) {
21228       {
21229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21230       };
21231     }
21232   }
21233
21234 }
21235
21236
21237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21238   void * jresult ;
21239   Dali::TypeInfo *arg1 = 0 ;
21240   Dali::TypeInfo *result = 0 ;
21241
21242   arg1 = (Dali::TypeInfo *)jarg1;
21243   if (!arg1) {
21244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21245     return 0;
21246   }
21247   {
21248     try {
21249       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21250     } catch (std::out_of_range& e) {
21251       {
21252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21253       };
21254     } catch (std::exception& e) {
21255       {
21256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21257       };
21258     } catch (Dali::DaliException e) {
21259       {
21260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21261       };
21262     } catch (...) {
21263       {
21264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21265       };
21266     }
21267   }
21268
21269   jresult = (void *)result;
21270   return jresult;
21271 }
21272
21273
21274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21275   void * jresult ;
21276   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21277   Dali::TypeInfo *arg2 = 0 ;
21278   Dali::TypeInfo *result = 0 ;
21279
21280   arg1 = (Dali::TypeInfo *)jarg1;
21281   arg2 = (Dali::TypeInfo *)jarg2;
21282   if (!arg2) {
21283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21284     return 0;
21285   }
21286   {
21287     try {
21288       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21289     } catch (std::out_of_range& e) {
21290       {
21291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21292       };
21293     } catch (std::exception& e) {
21294       {
21295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21296       };
21297     } catch (Dali::DaliException e) {
21298       {
21299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21300       };
21301     } catch (...) {
21302       {
21303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21304       };
21305     }
21306   }
21307
21308   jresult = (void *)result;
21309   return jresult;
21310 }
21311
21312
21313 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21314   char * jresult ;
21315   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21316   std::string *result = 0 ;
21317
21318   arg1 = (Dali::TypeInfo *)jarg1;
21319   {
21320     try {
21321       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21322     } catch (std::out_of_range& e) {
21323       {
21324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21325       };
21326     } catch (std::exception& e) {
21327       {
21328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21329       };
21330     } catch (Dali::DaliException e) {
21331       {
21332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21333       };
21334     } catch (...) {
21335       {
21336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21337       };
21338     }
21339   }
21340
21341   jresult = SWIG_csharp_string_callback(result->c_str());
21342   return jresult;
21343 }
21344
21345
21346 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21347   char * jresult ;
21348   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21349   std::string *result = 0 ;
21350
21351   arg1 = (Dali::TypeInfo *)jarg1;
21352   {
21353     try {
21354       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21355     } catch (std::out_of_range& e) {
21356       {
21357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21358       };
21359     } catch (std::exception& e) {
21360       {
21361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21362       };
21363     } catch (Dali::DaliException e) {
21364       {
21365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21366       };
21367     } catch (...) {
21368       {
21369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21370       };
21371     }
21372   }
21373
21374   jresult = SWIG_csharp_string_callback(result->c_str());
21375   return jresult;
21376 }
21377
21378
21379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21380   void * jresult ;
21381   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21382   Dali::BaseHandle result;
21383
21384   arg1 = (Dali::TypeInfo *)jarg1;
21385   {
21386     try {
21387       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21388     } catch (std::out_of_range& e) {
21389       {
21390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21391       };
21392     } catch (std::exception& e) {
21393       {
21394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21395       };
21396     } catch (Dali::DaliException e) {
21397       {
21398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21399       };
21400     } catch (...) {
21401       {
21402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21403       };
21404     }
21405   }
21406
21407   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21408   return jresult;
21409 }
21410
21411
21412 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21413   unsigned long jresult ;
21414   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21415   size_t result;
21416
21417   arg1 = (Dali::TypeInfo *)jarg1;
21418   {
21419     try {
21420       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21421     } catch (std::out_of_range& e) {
21422       {
21423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21424       };
21425     } catch (std::exception& e) {
21426       {
21427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21428       };
21429     } catch (Dali::DaliException e) {
21430       {
21431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21432       };
21433     } catch (...) {
21434       {
21435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21436       };
21437     }
21438   }
21439
21440   jresult = (unsigned long)result;
21441   return jresult;
21442 }
21443
21444
21445 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21446   char * jresult ;
21447   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21448   size_t arg2 ;
21449   std::string result;
21450
21451   arg1 = (Dali::TypeInfo *)jarg1;
21452   arg2 = (size_t)jarg2;
21453   {
21454     try {
21455       result = (arg1)->GetActionName(arg2);
21456     } catch (std::out_of_range& e) {
21457       {
21458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (std::exception& e) {
21461       {
21462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21463       };
21464     } catch (Dali::DaliException e) {
21465       {
21466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21467       };
21468     } catch (...) {
21469       {
21470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21471       };
21472     }
21473   }
21474
21475   jresult = SWIG_csharp_string_callback((&result)->c_str());
21476   return jresult;
21477 }
21478
21479
21480 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21481   unsigned long jresult ;
21482   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21483   size_t result;
21484
21485   arg1 = (Dali::TypeInfo *)jarg1;
21486   {
21487     try {
21488       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21489     } catch (std::out_of_range& e) {
21490       {
21491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (std::exception& e) {
21494       {
21495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21496       };
21497     } catch (Dali::DaliException e) {
21498       {
21499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21500       };
21501     } catch (...) {
21502       {
21503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21504       };
21505     }
21506   }
21507
21508   jresult = (unsigned long)result;
21509   return jresult;
21510 }
21511
21512
21513 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21514   char * jresult ;
21515   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21516   size_t arg2 ;
21517   std::string result;
21518
21519   arg1 = (Dali::TypeInfo *)jarg1;
21520   arg2 = (size_t)jarg2;
21521   {
21522     try {
21523       result = (arg1)->GetSignalName(arg2);
21524     } catch (std::out_of_range& e) {
21525       {
21526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21527       };
21528     } catch (std::exception& e) {
21529       {
21530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21531       };
21532     } catch (Dali::DaliException e) {
21533       {
21534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21535       };
21536     } catch (...) {
21537       {
21538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21539       };
21540     }
21541   }
21542
21543   jresult = SWIG_csharp_string_callback((&result)->c_str());
21544   return jresult;
21545 }
21546
21547
21548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21549   unsigned long jresult ;
21550   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21551   size_t result;
21552
21553   arg1 = (Dali::TypeInfo *)jarg1;
21554   {
21555     try {
21556       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21557     } catch (std::out_of_range& e) {
21558       {
21559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21560       };
21561     } catch (std::exception& e) {
21562       {
21563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21564       };
21565     } catch (Dali::DaliException e) {
21566       {
21567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21568       };
21569     } catch (...) {
21570       {
21571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21572       };
21573     }
21574   }
21575
21576   jresult = (unsigned long)result;
21577   return jresult;
21578 }
21579
21580
21581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21582   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21583   Dali::Property::IndexContainer *arg2 = 0 ;
21584
21585   arg1 = (Dali::TypeInfo *)jarg1;
21586   arg2 = (Dali::Property::IndexContainer *)jarg2;
21587   if (!arg2) {
21588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21589     return ;
21590   }
21591   {
21592     try {
21593       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21594     } catch (std::out_of_range& e) {
21595       {
21596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21597       };
21598     } catch (std::exception& e) {
21599       {
21600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21601       };
21602     } catch (Dali::DaliException e) {
21603       {
21604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21605       };
21606     } catch (...) {
21607       {
21608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21609       };
21610     }
21611   }
21612
21613 }
21614
21615
21616 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21617   char * jresult ;
21618   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21619   Dali::Property::Index arg2 ;
21620   std::string *result = 0 ;
21621
21622   arg1 = (Dali::TypeInfo *)jarg1;
21623   arg2 = (Dali::Property::Index)jarg2;
21624   {
21625     try {
21626       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21627     } catch (std::out_of_range& e) {
21628       {
21629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21630       };
21631     } catch (std::exception& e) {
21632       {
21633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21634       };
21635     } catch (Dali::DaliException e) {
21636       {
21637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21638       };
21639     } catch (...) {
21640       {
21641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21642       };
21643     }
21644   }
21645
21646   jresult = SWIG_csharp_string_callback(result->c_str());
21647   return jresult;
21648 }
21649
21650
21651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21652   void * jresult ;
21653   Dali::TypeRegistry result;
21654
21655   {
21656     try {
21657       result = Dali::TypeRegistry::Get();
21658     } catch (std::out_of_range& e) {
21659       {
21660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21661       };
21662     } catch (std::exception& e) {
21663       {
21664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21665       };
21666     } catch (Dali::DaliException e) {
21667       {
21668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21669       };
21670     } catch (...) {
21671       {
21672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21673       };
21674     }
21675   }
21676
21677   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21678   return jresult;
21679 }
21680
21681
21682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21683   void * jresult ;
21684   Dali::TypeRegistry *result = 0 ;
21685
21686   {
21687     try {
21688       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21689     } catch (std::out_of_range& e) {
21690       {
21691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21692       };
21693     } catch (std::exception& e) {
21694       {
21695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21696       };
21697     } catch (Dali::DaliException e) {
21698       {
21699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21700       };
21701     } catch (...) {
21702       {
21703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21704       };
21705     }
21706   }
21707
21708   jresult = (void *)result;
21709   return jresult;
21710 }
21711
21712
21713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21714   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21715
21716   arg1 = (Dali::TypeRegistry *)jarg1;
21717   {
21718     try {
21719       delete arg1;
21720     } catch (std::out_of_range& e) {
21721       {
21722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21723       };
21724     } catch (std::exception& e) {
21725       {
21726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21727       };
21728     } catch (Dali::DaliException e) {
21729       {
21730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21731       };
21732     } catch (...) {
21733       {
21734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21735       };
21736     }
21737   }
21738
21739 }
21740
21741
21742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21743   void * jresult ;
21744   Dali::TypeRegistry *arg1 = 0 ;
21745   Dali::TypeRegistry *result = 0 ;
21746
21747   arg1 = (Dali::TypeRegistry *)jarg1;
21748   if (!arg1) {
21749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21750     return 0;
21751   }
21752   {
21753     try {
21754       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21755     } catch (std::out_of_range& e) {
21756       {
21757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21758       };
21759     } catch (std::exception& e) {
21760       {
21761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21762       };
21763     } catch (Dali::DaliException e) {
21764       {
21765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21766       };
21767     } catch (...) {
21768       {
21769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21770       };
21771     }
21772   }
21773
21774   jresult = (void *)result;
21775   return jresult;
21776 }
21777
21778
21779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21780   void * jresult ;
21781   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21782   Dali::TypeRegistry *arg2 = 0 ;
21783   Dali::TypeRegistry *result = 0 ;
21784
21785   arg1 = (Dali::TypeRegistry *)jarg1;
21786   arg2 = (Dali::TypeRegistry *)jarg2;
21787   if (!arg2) {
21788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21789     return 0;
21790   }
21791   {
21792     try {
21793       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21794     } catch (std::out_of_range& e) {
21795       {
21796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21797       };
21798     } catch (std::exception& e) {
21799       {
21800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21801       };
21802     } catch (Dali::DaliException e) {
21803       {
21804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21805       };
21806     } catch (...) {
21807       {
21808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21809       };
21810     }
21811   }
21812
21813   jresult = (void *)result;
21814   return jresult;
21815 }
21816
21817
21818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21819   void * jresult ;
21820   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21821   std::string *arg2 = 0 ;
21822   Dali::TypeInfo result;
21823
21824   arg1 = (Dali::TypeRegistry *)jarg1;
21825   if (!jarg2) {
21826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21827     return 0;
21828   }
21829   std::string arg2_str(jarg2);
21830   arg2 = &arg2_str;
21831   {
21832     try {
21833       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21834     } catch (std::out_of_range& e) {
21835       {
21836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21837       };
21838     } catch (std::exception& e) {
21839       {
21840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21841       };
21842     } catch (Dali::DaliException e) {
21843       {
21844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21845       };
21846     } catch (...) {
21847       {
21848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21849       };
21850     }
21851   }
21852
21853   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21854
21855   //argout typemap for const std::string&
21856
21857   return jresult;
21858 }
21859
21860
21861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21862   void * jresult ;
21863   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21864   std::type_info *arg2 = 0 ;
21865   Dali::TypeInfo result;
21866
21867   arg1 = (Dali::TypeRegistry *)jarg1;
21868   arg2 = (std::type_info *)jarg2;
21869   if (!arg2) {
21870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21871     return 0;
21872   }
21873   {
21874     try {
21875       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21876     } catch (std::out_of_range& e) {
21877       {
21878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21879       };
21880     } catch (std::exception& e) {
21881       {
21882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21883       };
21884     } catch (Dali::DaliException e) {
21885       {
21886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21887       };
21888     } catch (...) {
21889       {
21890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21891       };
21892     }
21893   }
21894
21895   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21896   return jresult;
21897 }
21898
21899
21900 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21901   unsigned long jresult ;
21902   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21903   size_t result;
21904
21905   arg1 = (Dali::TypeRegistry *)jarg1;
21906   {
21907     try {
21908       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21909     } catch (std::out_of_range& e) {
21910       {
21911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21912       };
21913     } catch (std::exception& e) {
21914       {
21915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21916       };
21917     } catch (Dali::DaliException e) {
21918       {
21919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21920       };
21921     } catch (...) {
21922       {
21923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21924       };
21925     }
21926   }
21927
21928   jresult = (unsigned long)result;
21929   return jresult;
21930 }
21931
21932
21933 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21934   char * jresult ;
21935   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21936   size_t arg2 ;
21937   std::string result;
21938
21939   arg1 = (Dali::TypeRegistry *)jarg1;
21940   arg2 = (size_t)jarg2;
21941   {
21942     try {
21943       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21944     } catch (std::out_of_range& e) {
21945       {
21946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21947       };
21948     } catch (std::exception& e) {
21949       {
21950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21951       };
21952     } catch (Dali::DaliException e) {
21953       {
21954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21955       };
21956     } catch (...) {
21957       {
21958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21959       };
21960     }
21961   }
21962
21963   jresult = SWIG_csharp_string_callback((&result)->c_str());
21964   return jresult;
21965 }
21966
21967
21968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21969   void * jresult ;
21970   std::type_info *arg1 = 0 ;
21971   std::type_info *arg2 = 0 ;
21972   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21973   Dali::TypeRegistration *result = 0 ;
21974
21975   arg1 = (std::type_info *)jarg1;
21976   if (!arg1) {
21977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21978     return 0;
21979   }
21980   arg2 = (std::type_info *)jarg2;
21981   if (!arg2) {
21982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21983     return 0;
21984   }
21985   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21986   {
21987     try {
21988       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21989     } catch (std::out_of_range& e) {
21990       {
21991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21992       };
21993     } catch (std::exception& e) {
21994       {
21995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21996       };
21997     } catch (Dali::DaliException e) {
21998       {
21999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22000       };
22001     } catch (...) {
22002       {
22003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22004       };
22005     }
22006   }
22007
22008   jresult = (void *)result;
22009   return jresult;
22010 }
22011
22012
22013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22014   void * jresult ;
22015   std::type_info *arg1 = 0 ;
22016   std::type_info *arg2 = 0 ;
22017   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22018   bool arg4 ;
22019   Dali::TypeRegistration *result = 0 ;
22020
22021   arg1 = (std::type_info *)jarg1;
22022   if (!arg1) {
22023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22024     return 0;
22025   }
22026   arg2 = (std::type_info *)jarg2;
22027   if (!arg2) {
22028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22029     return 0;
22030   }
22031   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22032   arg4 = jarg4 ? true : false;
22033   {
22034     try {
22035       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22036     } catch (std::out_of_range& e) {
22037       {
22038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22039       };
22040     } catch (std::exception& e) {
22041       {
22042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22043       };
22044     } catch (Dali::DaliException e) {
22045       {
22046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22047       };
22048     } catch (...) {
22049       {
22050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22051       };
22052     }
22053   }
22054
22055   jresult = (void *)result;
22056   return jresult;
22057 }
22058
22059
22060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22061   void * jresult ;
22062   std::string *arg1 = 0 ;
22063   std::type_info *arg2 = 0 ;
22064   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22065   Dali::TypeRegistration *result = 0 ;
22066
22067   if (!jarg1) {
22068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22069     return 0;
22070   }
22071   std::string arg1_str(jarg1);
22072   arg1 = &arg1_str;
22073   arg2 = (std::type_info *)jarg2;
22074   if (!arg2) {
22075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22076     return 0;
22077   }
22078   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22079   {
22080     try {
22081       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22082     } catch (std::out_of_range& e) {
22083       {
22084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22085       };
22086     } catch (std::exception& e) {
22087       {
22088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22089       };
22090     } catch (Dali::DaliException e) {
22091       {
22092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22093       };
22094     } catch (...) {
22095       {
22096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22097       };
22098     }
22099   }
22100
22101   jresult = (void *)result;
22102
22103   //argout typemap for const std::string&
22104
22105   return jresult;
22106 }
22107
22108
22109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22110   char * jresult ;
22111   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22112   std::string result;
22113
22114   arg1 = (Dali::TypeRegistration *)jarg1;
22115   {
22116     try {
22117       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22118     } catch (std::out_of_range& e) {
22119       {
22120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (std::exception& e) {
22123       {
22124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22125       };
22126     } catch (Dali::DaliException e) {
22127       {
22128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22129       };
22130     } catch (...) {
22131       {
22132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22133       };
22134     }
22135   }
22136
22137   jresult = SWIG_csharp_string_callback((&result)->c_str());
22138   return jresult;
22139 }
22140
22141
22142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22143   std::string *arg1 = 0 ;
22144   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22145
22146   if (!jarg1) {
22147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22148     return ;
22149   }
22150   std::string arg1_str(jarg1);
22151   arg1 = &arg1_str;
22152   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22153   {
22154     try {
22155       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22156     } catch (std::out_of_range& e) {
22157       {
22158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22159       };
22160     } catch (std::exception& e) {
22161       {
22162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22163       };
22164     } catch (Dali::DaliException e) {
22165       {
22166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22167       };
22168     } catch (...) {
22169       {
22170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22171       };
22172     }
22173   }
22174
22175
22176   //argout typemap for const std::string&
22177
22178 }
22179
22180
22181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22182   std::string *arg1 = 0 ;
22183   std::string *arg2 = 0 ;
22184   int arg3 ;
22185   Dali::Property::Type arg4 ;
22186   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22187   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22188
22189   if (!jarg1) {
22190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22191     return ;
22192   }
22193   std::string arg1_str(jarg1);
22194   arg1 = &arg1_str;
22195   if (!jarg2) {
22196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22197     return ;
22198   }
22199   std::string arg2_str(jarg2);
22200   arg2 = &arg2_str;
22201   arg3 = (int)jarg3;
22202   arg4 = (Dali::Property::Type)jarg4;
22203   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22204   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22205   {
22206     try {
22207       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22208     } catch (std::out_of_range& e) {
22209       {
22210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22211       };
22212     } catch (std::exception& e) {
22213       {
22214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22215       };
22216     } catch (Dali::DaliException e) {
22217       {
22218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22219       };
22220     } catch (...) {
22221       {
22222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22223       };
22224     }
22225   }
22226
22227
22228   //argout typemap for const std::string&
22229
22230
22231   //argout typemap for const std::string&
22232
22233 }
22234
22235
22236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22237   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22238
22239   arg1 = (Dali::TypeRegistration *)jarg1;
22240   {
22241     try {
22242       delete arg1;
22243     } catch (std::out_of_range& e) {
22244       {
22245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22246       };
22247     } catch (std::exception& e) {
22248       {
22249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22250       };
22251     } catch (Dali::DaliException e) {
22252       {
22253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22254       };
22255     } catch (...) {
22256       {
22257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22258       };
22259     }
22260   }
22261
22262 }
22263
22264
22265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22266   void * jresult ;
22267   Dali::TypeRegistration *arg1 = 0 ;
22268   std::string *arg2 = 0 ;
22269   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22270   Dali::SignalConnectorType *result = 0 ;
22271
22272   arg1 = (Dali::TypeRegistration *)jarg1;
22273   if (!arg1) {
22274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22275     return 0;
22276   }
22277   if (!jarg2) {
22278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22279     return 0;
22280   }
22281   std::string arg2_str(jarg2);
22282   arg2 = &arg2_str;
22283   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22284   {
22285     try {
22286       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22287     } catch (std::out_of_range& e) {
22288       {
22289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22290       };
22291     } catch (std::exception& e) {
22292       {
22293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22294       };
22295     } catch (Dali::DaliException e) {
22296       {
22297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22298       };
22299     } catch (...) {
22300       {
22301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22302       };
22303     }
22304   }
22305
22306   jresult = (void *)result;
22307
22308   //argout typemap for const std::string&
22309
22310   return jresult;
22311 }
22312
22313
22314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22315   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22316
22317   arg1 = (Dali::SignalConnectorType *)jarg1;
22318   {
22319     try {
22320       delete arg1;
22321     } catch (std::out_of_range& e) {
22322       {
22323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22324       };
22325     } catch (std::exception& e) {
22326       {
22327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22328       };
22329     } catch (Dali::DaliException e) {
22330       {
22331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22332       };
22333     } catch (...) {
22334       {
22335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22336       };
22337     }
22338   }
22339
22340 }
22341
22342
22343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22344   void * jresult ;
22345   Dali::TypeRegistration *arg1 = 0 ;
22346   std::string *arg2 = 0 ;
22347   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22348   Dali::TypeAction *result = 0 ;
22349
22350   arg1 = (Dali::TypeRegistration *)jarg1;
22351   if (!arg1) {
22352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22353     return 0;
22354   }
22355   if (!jarg2) {
22356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22357     return 0;
22358   }
22359   std::string arg2_str(jarg2);
22360   arg2 = &arg2_str;
22361   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22362   {
22363     try {
22364       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22365     } catch (std::out_of_range& e) {
22366       {
22367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22368       };
22369     } catch (std::exception& e) {
22370       {
22371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22372       };
22373     } catch (Dali::DaliException e) {
22374       {
22375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22376       };
22377     } catch (...) {
22378       {
22379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22380       };
22381     }
22382   }
22383
22384   jresult = (void *)result;
22385
22386   //argout typemap for const std::string&
22387
22388   return jresult;
22389 }
22390
22391
22392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22393   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22394
22395   arg1 = (Dali::TypeAction *)jarg1;
22396   {
22397     try {
22398       delete arg1;
22399     } catch (std::out_of_range& e) {
22400       {
22401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22402       };
22403     } catch (std::exception& e) {
22404       {
22405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22406       };
22407     } catch (Dali::DaliException e) {
22408       {
22409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22410       };
22411     } catch (...) {
22412       {
22413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22414       };
22415     }
22416   }
22417
22418 }
22419
22420
22421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22422   void * jresult ;
22423   Dali::TypeRegistration *arg1 = 0 ;
22424   std::string *arg2 = 0 ;
22425   Dali::Property::Index arg3 ;
22426   Dali::Property::Type arg4 ;
22427   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22428   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22429   Dali::PropertyRegistration *result = 0 ;
22430
22431   arg1 = (Dali::TypeRegistration *)jarg1;
22432   if (!arg1) {
22433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22434     return 0;
22435   }
22436   if (!jarg2) {
22437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22438     return 0;
22439   }
22440   std::string arg2_str(jarg2);
22441   arg2 = &arg2_str;
22442   arg3 = (Dali::Property::Index)jarg3;
22443   arg4 = (Dali::Property::Type)jarg4;
22444   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22445   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22446   {
22447     try {
22448       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22449     } catch (std::out_of_range& e) {
22450       {
22451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22452       };
22453     } catch (std::exception& e) {
22454       {
22455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22456       };
22457     } catch (Dali::DaliException e) {
22458       {
22459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22460       };
22461     } catch (...) {
22462       {
22463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22464       };
22465     }
22466   }
22467
22468   jresult = (void *)result;
22469
22470   //argout typemap for const std::string&
22471
22472   return jresult;
22473 }
22474
22475
22476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22477   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22478
22479   arg1 = (Dali::PropertyRegistration *)jarg1;
22480   {
22481     try {
22482       delete arg1;
22483     } catch (std::out_of_range& e) {
22484       {
22485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22486       };
22487     } catch (std::exception& e) {
22488       {
22489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22490       };
22491     } catch (Dali::DaliException e) {
22492       {
22493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22494       };
22495     } catch (...) {
22496       {
22497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22498       };
22499     }
22500   }
22501
22502 }
22503
22504
22505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22506   void * jresult ;
22507   Dali::TypeRegistration *arg1 = 0 ;
22508   std::string *arg2 = 0 ;
22509   Dali::Property::Index arg3 ;
22510   Dali::Property::Type arg4 ;
22511   Dali::AnimatablePropertyRegistration *result = 0 ;
22512
22513   arg1 = (Dali::TypeRegistration *)jarg1;
22514   if (!arg1) {
22515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22516     return 0;
22517   }
22518   if (!jarg2) {
22519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22520     return 0;
22521   }
22522   std::string arg2_str(jarg2);
22523   arg2 = &arg2_str;
22524   arg3 = (Dali::Property::Index)jarg3;
22525   arg4 = (Dali::Property::Type)jarg4;
22526   {
22527     try {
22528       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22529     } catch (std::out_of_range& e) {
22530       {
22531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22532       };
22533     } catch (std::exception& e) {
22534       {
22535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22536       };
22537     } catch (Dali::DaliException e) {
22538       {
22539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22540       };
22541     } catch (...) {
22542       {
22543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22544       };
22545     }
22546   }
22547
22548   jresult = (void *)result;
22549
22550   //argout typemap for const std::string&
22551
22552   return jresult;
22553 }
22554
22555
22556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22557   void * jresult ;
22558   Dali::TypeRegistration *arg1 = 0 ;
22559   std::string *arg2 = 0 ;
22560   Dali::Property::Index arg3 ;
22561   Dali::Property::Value *arg4 = 0 ;
22562   Dali::AnimatablePropertyRegistration *result = 0 ;
22563
22564   arg1 = (Dali::TypeRegistration *)jarg1;
22565   if (!arg1) {
22566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22567     return 0;
22568   }
22569   if (!jarg2) {
22570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22571     return 0;
22572   }
22573   std::string arg2_str(jarg2);
22574   arg2 = &arg2_str;
22575   arg3 = (Dali::Property::Index)jarg3;
22576   arg4 = (Dali::Property::Value *)jarg4;
22577   if (!arg4) {
22578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22579     return 0;
22580   }
22581   {
22582     try {
22583       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22584     } catch (std::out_of_range& e) {
22585       {
22586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22587       };
22588     } catch (std::exception& e) {
22589       {
22590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22591       };
22592     } catch (Dali::DaliException e) {
22593       {
22594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22595       };
22596     } catch (...) {
22597       {
22598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22599       };
22600     }
22601   }
22602
22603   jresult = (void *)result;
22604
22605   //argout typemap for const std::string&
22606
22607   return jresult;
22608 }
22609
22610
22611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22612   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22613
22614   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22615   {
22616     try {
22617       delete arg1;
22618     } catch (std::out_of_range& e) {
22619       {
22620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22621       };
22622     } catch (std::exception& e) {
22623       {
22624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22625       };
22626     } catch (Dali::DaliException e) {
22627       {
22628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22629       };
22630     } catch (...) {
22631       {
22632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22633       };
22634     }
22635   }
22636
22637 }
22638
22639
22640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22641   void * jresult ;
22642   Dali::TypeRegistration *arg1 = 0 ;
22643   std::string *arg2 = 0 ;
22644   Dali::Property::Index arg3 ;
22645   Dali::Property::Index arg4 ;
22646   unsigned int arg5 ;
22647   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22648
22649   arg1 = (Dali::TypeRegistration *)jarg1;
22650   if (!arg1) {
22651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22652     return 0;
22653   }
22654   if (!jarg2) {
22655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22656     return 0;
22657   }
22658   std::string arg2_str(jarg2);
22659   arg2 = &arg2_str;
22660   arg3 = (Dali::Property::Index)jarg3;
22661   arg4 = (Dali::Property::Index)jarg4;
22662   arg5 = (unsigned int)jarg5;
22663   {
22664     try {
22665       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22666     } catch (std::out_of_range& e) {
22667       {
22668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22669       };
22670     } catch (std::exception& e) {
22671       {
22672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22673       };
22674     } catch (Dali::DaliException e) {
22675       {
22676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22677       };
22678     } catch (...) {
22679       {
22680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22681       };
22682     }
22683   }
22684
22685   jresult = (void *)result;
22686
22687   //argout typemap for const std::string&
22688
22689   return jresult;
22690 }
22691
22692
22693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22694   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22695
22696   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22697   {
22698     try {
22699       delete arg1;
22700     } catch (std::out_of_range& e) {
22701       {
22702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22703       };
22704     } catch (std::exception& e) {
22705       {
22706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22707       };
22708     } catch (Dali::DaliException e) {
22709       {
22710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22711       };
22712     } catch (...) {
22713       {
22714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22715       };
22716     }
22717   }
22718
22719 }
22720
22721
22722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22723   void * jresult ;
22724   Dali::TypeRegistration *arg1 = 0 ;
22725   std::string *arg2 = 0 ;
22726   Dali::Property::Index arg3 ;
22727   Dali::Property::Type arg4 ;
22728   Dali::ChildPropertyRegistration *result = 0 ;
22729
22730   arg1 = (Dali::TypeRegistration *)jarg1;
22731   if (!arg1) {
22732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22733     return 0;
22734   }
22735   if (!jarg2) {
22736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22737     return 0;
22738   }
22739   std::string arg2_str(jarg2);
22740   arg2 = &arg2_str;
22741   arg3 = (Dali::Property::Index)jarg3;
22742   arg4 = (Dali::Property::Type)jarg4;
22743   {
22744     try {
22745       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22746     } catch (std::out_of_range& e) {
22747       {
22748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22749       };
22750     } catch (std::exception& e) {
22751       {
22752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22753       };
22754     } catch (Dali::DaliException e) {
22755       {
22756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22757       };
22758     } catch (...) {
22759       {
22760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22761       };
22762     }
22763   }
22764
22765   jresult = (void *)result;
22766
22767   //argout typemap for const std::string&
22768
22769   return jresult;
22770 }
22771
22772
22773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22774   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22775
22776   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22777   {
22778     try {
22779       delete arg1;
22780     } catch (std::out_of_range& e) {
22781       {
22782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22783       };
22784     } catch (std::exception& e) {
22785       {
22786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22787       };
22788     } catch (Dali::DaliException e) {
22789       {
22790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22791       };
22792     } catch (...) {
22793       {
22794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22795       };
22796     }
22797   }
22798
22799 }
22800
22801
22802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22803   unsigned int jresult ;
22804   std::string *arg1 = 0 ;
22805   std::type_info *arg2 = 0 ;
22806   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22807   bool result;
22808
22809   if (!jarg1) {
22810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22811     return 0;
22812   }
22813   std::string arg1_str(jarg1);
22814   arg1 = &arg1_str;
22815   arg2 = (std::type_info *)jarg2;
22816   if (!arg2) {
22817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22818     return 0;
22819   }
22820   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22821   {
22822     try {
22823       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22824     } catch (std::out_of_range& e) {
22825       {
22826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22827       };
22828     } catch (std::exception& e) {
22829       {
22830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22831       };
22832     } catch (Dali::DaliException e) {
22833       {
22834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22835       };
22836     } catch (...) {
22837       {
22838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22839       };
22840     }
22841   }
22842
22843   jresult = result;
22844
22845   //argout typemap for const std::string&
22846
22847   return jresult;
22848 }
22849
22850
22851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22852   unsigned int jresult ;
22853   std::string *arg1 = 0 ;
22854   std::string *arg2 = 0 ;
22855   Dali::Property::Index arg3 ;
22856   Dali::Property::Type arg4 ;
22857   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22858   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22859   bool result;
22860
22861   if (!jarg1) {
22862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22863     return 0;
22864   }
22865   std::string arg1_str(jarg1);
22866   arg1 = &arg1_str;
22867   if (!jarg2) {
22868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22869     return 0;
22870   }
22871   std::string arg2_str(jarg2);
22872   arg2 = &arg2_str;
22873   arg3 = (Dali::Property::Index)jarg3;
22874   arg4 = (Dali::Property::Type)jarg4;
22875   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22876   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22877   {
22878     try {
22879       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22880     } catch (std::out_of_range& e) {
22881       {
22882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22883       };
22884     } catch (std::exception& e) {
22885       {
22886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22887       };
22888     } catch (Dali::DaliException e) {
22889       {
22890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22891       };
22892     } catch (...) {
22893       {
22894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22895       };
22896     }
22897   }
22898
22899   jresult = result;
22900
22901   //argout typemap for const std::string&
22902
22903
22904   //argout typemap for const std::string&
22905
22906   return jresult;
22907 }
22908
22909
22910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22911   float jresult ;
22912   float result;
22913
22914   result = (float)(float)Dali::ParentOrigin::TOP;
22915   jresult = result;
22916   return jresult;
22917 }
22918
22919
22920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22921   float jresult ;
22922   float result;
22923
22924   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22925   jresult = result;
22926   return jresult;
22927 }
22928
22929
22930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22931   float jresult ;
22932   float result;
22933
22934   result = (float)(float)Dali::ParentOrigin::LEFT;
22935   jresult = result;
22936   return jresult;
22937 }
22938
22939
22940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22941   float jresult ;
22942   float result;
22943
22944   result = (float)(float)Dali::ParentOrigin::RIGHT;
22945   jresult = result;
22946   return jresult;
22947 }
22948
22949
22950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22951   float jresult ;
22952   float result;
22953
22954   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22955   jresult = result;
22956   return jresult;
22957 }
22958
22959
22960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22961   void * jresult ;
22962   Dali::Vector3 *result = 0 ;
22963
22964   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22965   jresult = (void *)result;
22966   return jresult;
22967 }
22968
22969
22970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22971   void * jresult ;
22972   Dali::Vector3 *result = 0 ;
22973
22974   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22975   jresult = (void *)result;
22976   return jresult;
22977 }
22978
22979
22980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22981   void * jresult ;
22982   Dali::Vector3 *result = 0 ;
22983
22984   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22985   jresult = (void *)result;
22986   return jresult;
22987 }
22988
22989
22990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22991   void * jresult ;
22992   Dali::Vector3 *result = 0 ;
22993
22994   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22995   jresult = (void *)result;
22996   return jresult;
22997 }
22998
22999
23000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23001   void * jresult ;
23002   Dali::Vector3 *result = 0 ;
23003
23004   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23005   jresult = (void *)result;
23006   return jresult;
23007 }
23008
23009
23010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23011   void * jresult ;
23012   Dali::Vector3 *result = 0 ;
23013
23014   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23015   jresult = (void *)result;
23016   return jresult;
23017 }
23018
23019
23020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23021   void * jresult ;
23022   Dali::Vector3 *result = 0 ;
23023
23024   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23025   jresult = (void *)result;
23026   return jresult;
23027 }
23028
23029
23030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23031   void * jresult ;
23032   Dali::Vector3 *result = 0 ;
23033
23034   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23035   jresult = (void *)result;
23036   return jresult;
23037 }
23038
23039
23040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23041   void * jresult ;
23042   Dali::Vector3 *result = 0 ;
23043
23044   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23045   jresult = (void *)result;
23046   return jresult;
23047 }
23048
23049
23050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23051   float jresult ;
23052   float result;
23053
23054   result = (float)(float)Dali::AnchorPoint::TOP;
23055   jresult = result;
23056   return jresult;
23057 }
23058
23059
23060 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23061   float jresult ;
23062   float result;
23063
23064   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23065   jresult = result;
23066   return jresult;
23067 }
23068
23069
23070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23071   float jresult ;
23072   float result;
23073
23074   result = (float)(float)Dali::AnchorPoint::LEFT;
23075   jresult = result;
23076   return jresult;
23077 }
23078
23079
23080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23081   float jresult ;
23082   float result;
23083
23084   result = (float)(float)Dali::AnchorPoint::RIGHT;
23085   jresult = result;
23086   return jresult;
23087 }
23088
23089
23090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23091   float jresult ;
23092   float result;
23093
23094   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23095   jresult = result;
23096   return jresult;
23097 }
23098
23099
23100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23101   void * jresult ;
23102   Dali::Vector3 *result = 0 ;
23103
23104   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23105   jresult = (void *)result;
23106   return jresult;
23107 }
23108
23109
23110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23111   void * jresult ;
23112   Dali::Vector3 *result = 0 ;
23113
23114   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23115   jresult = (void *)result;
23116   return jresult;
23117 }
23118
23119
23120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23121   void * jresult ;
23122   Dali::Vector3 *result = 0 ;
23123
23124   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23125   jresult = (void *)result;
23126   return jresult;
23127 }
23128
23129
23130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23131   void * jresult ;
23132   Dali::Vector3 *result = 0 ;
23133
23134   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23135   jresult = (void *)result;
23136   return jresult;
23137 }
23138
23139
23140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23141   void * jresult ;
23142   Dali::Vector3 *result = 0 ;
23143
23144   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23145   jresult = (void *)result;
23146   return jresult;
23147 }
23148
23149
23150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23151   void * jresult ;
23152   Dali::Vector3 *result = 0 ;
23153
23154   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23155   jresult = (void *)result;
23156   return jresult;
23157 }
23158
23159
23160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23161   void * jresult ;
23162   Dali::Vector3 *result = 0 ;
23163
23164   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23165   jresult = (void *)result;
23166   return jresult;
23167 }
23168
23169
23170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23171   void * jresult ;
23172   Dali::Vector3 *result = 0 ;
23173
23174   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23175   jresult = (void *)result;
23176   return jresult;
23177 }
23178
23179
23180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23181   void * jresult ;
23182   Dali::Vector3 *result = 0 ;
23183
23184   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23185   jresult = (void *)result;
23186   return jresult;
23187 }
23188
23189
23190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23191   void * jresult ;
23192   Dali::Vector4 *result = 0 ;
23193
23194   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23195   jresult = (void *)result;
23196   return jresult;
23197 }
23198
23199
23200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23201   void * jresult ;
23202   Dali::Vector4 *result = 0 ;
23203
23204   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23205   jresult = (void *)result;
23206   return jresult;
23207 }
23208
23209
23210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23211   void * jresult ;
23212   Dali::Vector4 *result = 0 ;
23213
23214   result = (Dali::Vector4 *)&Dali::Color::RED;
23215   jresult = (void *)result;
23216   return jresult;
23217 }
23218
23219
23220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23221   void * jresult ;
23222   Dali::Vector4 *result = 0 ;
23223
23224   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23225   jresult = (void *)result;
23226   return jresult;
23227 }
23228
23229
23230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23231   void * jresult ;
23232   Dali::Vector4 *result = 0 ;
23233
23234   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23235   jresult = (void *)result;
23236   return jresult;
23237 }
23238
23239
23240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23241   void * jresult ;
23242   Dali::Vector4 *result = 0 ;
23243
23244   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23245   jresult = (void *)result;
23246   return jresult;
23247 }
23248
23249
23250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23251   void * jresult ;
23252   Dali::Vector4 *result = 0 ;
23253
23254   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23255   jresult = (void *)result;
23256   return jresult;
23257 }
23258
23259
23260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23261   void * jresult ;
23262   Dali::Vector4 *result = 0 ;
23263
23264   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23265   jresult = (void *)result;
23266   return jresult;
23267 }
23268
23269
23270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23271   void * jresult ;
23272   Dali::Vector4 *result = 0 ;
23273
23274   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23275   jresult = (void *)result;
23276   return jresult;
23277 }
23278
23279
23280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23281   float jresult ;
23282   float result;
23283
23284   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23285   jresult = result;
23286   return jresult;
23287 }
23288
23289
23290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23291   float jresult ;
23292   float result;
23293
23294   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23295   jresult = result;
23296   return jresult;
23297 }
23298
23299
23300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23301   float jresult ;
23302   float result;
23303
23304   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23305   jresult = result;
23306   return jresult;
23307 }
23308
23309
23310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23311   float jresult ;
23312   float result;
23313
23314   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23315   jresult = result;
23316   return jresult;
23317 }
23318
23319
23320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23321   float jresult ;
23322   float result;
23323
23324   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23325   jresult = result;
23326   return jresult;
23327 }
23328
23329
23330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23331   float jresult ;
23332   float result;
23333
23334   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23335   jresult = result;
23336   return jresult;
23337 }
23338
23339
23340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23341   float jresult ;
23342   float result;
23343
23344   result = (float)(float)Dali::Math::PI;
23345   jresult = result;
23346   return jresult;
23347 }
23348
23349
23350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23351   float jresult ;
23352   float result;
23353
23354   result = (float)(float)Dali::Math::PI_2;
23355   jresult = result;
23356   return jresult;
23357 }
23358
23359
23360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23361   float jresult ;
23362   float result;
23363
23364   result = (float)(float)Dali::Math::PI_4;
23365   jresult = result;
23366   return jresult;
23367 }
23368
23369
23370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23371   float jresult ;
23372   float result;
23373
23374   result = (float)(float)Dali::Math::PI_OVER_180;
23375   jresult = result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23381   float jresult ;
23382   float result;
23383
23384   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23385   jresult = result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23391   int jresult ;
23392   Dali::ResizePolicy::Type result;
23393
23394   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23395   jresult = (int)result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23401   unsigned long jresult ;
23402   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23403   Dali::VectorBase::SizeType result;
23404
23405   arg1 = (Dali::VectorBase *)jarg1;
23406   {
23407     try {
23408       result = ((Dali::VectorBase const *)arg1)->Count();
23409     } catch (std::out_of_range& e) {
23410       {
23411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23412       };
23413     } catch (std::exception& e) {
23414       {
23415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23416       };
23417     } catch (Dali::DaliException e) {
23418       {
23419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23420       };
23421     } catch (...) {
23422       {
23423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23424       };
23425     }
23426   }
23427
23428   jresult = (unsigned long)result;
23429   return jresult;
23430 }
23431
23432
23433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23434   unsigned long jresult ;
23435   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23436   Dali::VectorBase::SizeType result;
23437
23438   arg1 = (Dali::VectorBase *)jarg1;
23439   {
23440     try {
23441       result = ((Dali::VectorBase const *)arg1)->Size();
23442     } catch (std::out_of_range& e) {
23443       {
23444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23445       };
23446     } catch (std::exception& e) {
23447       {
23448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23449       };
23450     } catch (Dali::DaliException e) {
23451       {
23452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23453       };
23454     } catch (...) {
23455       {
23456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23457       };
23458     }
23459   }
23460
23461   jresult = (unsigned long)result;
23462   return jresult;
23463 }
23464
23465
23466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23467   unsigned int jresult ;
23468   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23469   bool result;
23470
23471   arg1 = (Dali::VectorBase *)jarg1;
23472   {
23473     try {
23474       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23475     } catch (std::out_of_range& e) {
23476       {
23477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23478       };
23479     } catch (std::exception& e) {
23480       {
23481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23482       };
23483     } catch (Dali::DaliException e) {
23484       {
23485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23486       };
23487     } catch (...) {
23488       {
23489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23490       };
23491     }
23492   }
23493
23494   jresult = result;
23495   return jresult;
23496 }
23497
23498
23499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23500   unsigned long jresult ;
23501   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23502   Dali::VectorBase::SizeType result;
23503
23504   arg1 = (Dali::VectorBase *)jarg1;
23505   {
23506     try {
23507       result = ((Dali::VectorBase const *)arg1)->Capacity();
23508     } catch (std::out_of_range& e) {
23509       {
23510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23511       };
23512     } catch (std::exception& e) {
23513       {
23514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23515       };
23516     } catch (Dali::DaliException e) {
23517       {
23518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23519       };
23520     } catch (...) {
23521       {
23522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23523       };
23524     }
23525   }
23526
23527   jresult = (unsigned long)result;
23528   return jresult;
23529 }
23530
23531
23532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23533   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23534
23535   arg1 = (Dali::VectorBase *)jarg1;
23536   {
23537     try {
23538       (arg1)->Release();
23539     } catch (std::out_of_range& e) {
23540       {
23541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23542       };
23543     } catch (std::exception& e) {
23544       {
23545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23546       };
23547     } catch (Dali::DaliException e) {
23548       {
23549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23550       };
23551     } catch (...) {
23552       {
23553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23554       };
23555     }
23556   }
23557
23558 }
23559
23560
23561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23562   void * jresult ;
23563   Dali::Image *result = 0 ;
23564
23565   {
23566     try {
23567       result = (Dali::Image *)new Dali::Image();
23568     } catch (std::out_of_range& e) {
23569       {
23570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23571       };
23572     } catch (std::exception& e) {
23573       {
23574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23575       };
23576     } catch (Dali::DaliException e) {
23577       {
23578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23579       };
23580     } catch (...) {
23581       {
23582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23583       };
23584     }
23585   }
23586
23587   jresult = (void *)result;
23588   return jresult;
23589 }
23590
23591
23592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23593   Dali::Image *arg1 = (Dali::Image *) 0 ;
23594
23595   arg1 = (Dali::Image *)jarg1;
23596   {
23597     try {
23598       delete arg1;
23599     } catch (std::out_of_range& e) {
23600       {
23601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23602       };
23603     } catch (std::exception& e) {
23604       {
23605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23606       };
23607     } catch (Dali::DaliException e) {
23608       {
23609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23610       };
23611     } catch (...) {
23612       {
23613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23614       };
23615     }
23616   }
23617
23618 }
23619
23620
23621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23622   void * jresult ;
23623   Dali::Image *arg1 = 0 ;
23624   Dali::Image *result = 0 ;
23625
23626   arg1 = (Dali::Image *)jarg1;
23627   if (!arg1) {
23628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23629     return 0;
23630   }
23631   {
23632     try {
23633       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23634     } catch (std::out_of_range& e) {
23635       {
23636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23637       };
23638     } catch (std::exception& e) {
23639       {
23640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23641       };
23642     } catch (Dali::DaliException e) {
23643       {
23644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23645       };
23646     } catch (...) {
23647       {
23648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23649       };
23650     }
23651   }
23652
23653   jresult = (void *)result;
23654   return jresult;
23655 }
23656
23657
23658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23659   void * jresult ;
23660   Dali::Image *arg1 = (Dali::Image *) 0 ;
23661   Dali::Image *arg2 = 0 ;
23662   Dali::Image *result = 0 ;
23663
23664   arg1 = (Dali::Image *)jarg1;
23665   arg2 = (Dali::Image *)jarg2;
23666   if (!arg2) {
23667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23668     return 0;
23669   }
23670   {
23671     try {
23672       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23673     } catch (std::out_of_range& e) {
23674       {
23675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23676       };
23677     } catch (std::exception& e) {
23678       {
23679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23680       };
23681     } catch (Dali::DaliException e) {
23682       {
23683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23684       };
23685     } catch (...) {
23686       {
23687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23688       };
23689     }
23690   }
23691
23692   jresult = (void *)result;
23693   return jresult;
23694 }
23695
23696
23697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23698   void * jresult ;
23699   Dali::BaseHandle arg1 ;
23700   Dali::BaseHandle *argp1 ;
23701   Dali::Image result;
23702
23703   argp1 = (Dali::BaseHandle *)jarg1;
23704   if (!argp1) {
23705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23706     return 0;
23707   }
23708   arg1 = *argp1;
23709   {
23710     try {
23711       result = Dali::Image::DownCast(arg1);
23712     } catch (std::out_of_range& e) {
23713       {
23714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23715       };
23716     } catch (std::exception& e) {
23717       {
23718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23719       };
23720     } catch (Dali::DaliException e) {
23721       {
23722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23723       };
23724     } catch (...) {
23725       {
23726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23727       };
23728     }
23729   }
23730
23731   jresult = new Dali::Image((const Dali::Image &)result);
23732   return jresult;
23733 }
23734
23735
23736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23737   unsigned int jresult ;
23738   Dali::Image *arg1 = (Dali::Image *) 0 ;
23739   unsigned int result;
23740
23741   arg1 = (Dali::Image *)jarg1;
23742   {
23743     try {
23744       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23745     } catch (std::out_of_range& e) {
23746       {
23747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23748       };
23749     } catch (std::exception& e) {
23750       {
23751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23752       };
23753     } catch (Dali::DaliException e) {
23754       {
23755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23756       };
23757     } catch (...) {
23758       {
23759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23760       };
23761     }
23762   }
23763
23764   jresult = result;
23765   return jresult;
23766 }
23767
23768
23769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23770   unsigned int jresult ;
23771   Dali::Image *arg1 = (Dali::Image *) 0 ;
23772   unsigned int result;
23773
23774   arg1 = (Dali::Image *)jarg1;
23775   {
23776     try {
23777       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23778     } catch (std::out_of_range& e) {
23779       {
23780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23781       };
23782     } catch (std::exception& e) {
23783       {
23784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23785       };
23786     } catch (Dali::DaliException e) {
23787       {
23788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23789       };
23790     } catch (...) {
23791       {
23792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23793       };
23794     }
23795   }
23796
23797   jresult = result;
23798   return jresult;
23799 }
23800
23801
23802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23803   void * jresult ;
23804   Dali::Image *arg1 = (Dali::Image *) 0 ;
23805   Dali::Image::ImageSignalType *result = 0 ;
23806
23807   arg1 = (Dali::Image *)jarg1;
23808   {
23809     try {
23810       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23811     } catch (std::out_of_range& e) {
23812       {
23813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23814       };
23815     } catch (std::exception& e) {
23816       {
23817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23818       };
23819     } catch (Dali::DaliException e) {
23820       {
23821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23822       };
23823     } catch (...) {
23824       {
23825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23826       };
23827     }
23828   }
23829
23830   jresult = (void *)result;
23831   return jresult;
23832 }
23833
23834
23835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23836   int jresult ;
23837   Dali::Pixel::Format result;
23838
23839   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23840   jresult = (int)result;
23841   return jresult;
23842 }
23843
23844
23845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23846   int jresult ;
23847   Dali::Pixel::Format result;
23848
23849   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23850   jresult = (int)result;
23851   return jresult;
23852 }
23853
23854
23855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23856   unsigned int jresult ;
23857   Dali::Pixel::Format arg1 ;
23858   bool result;
23859
23860   arg1 = (Dali::Pixel::Format)jarg1;
23861   {
23862     try {
23863       result = (bool)Dali::Pixel::HasAlpha(arg1);
23864     } catch (std::out_of_range& e) {
23865       {
23866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23867       };
23868     } catch (std::exception& e) {
23869       {
23870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23871       };
23872     } catch (Dali::DaliException e) {
23873       {
23874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23875       };
23876     } catch (...) {
23877       {
23878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23879       };
23880     }
23881   }
23882
23883   jresult = result;
23884   return jresult;
23885 }
23886
23887
23888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23889   unsigned int jresult ;
23890   Dali::Pixel::Format arg1 ;
23891   unsigned int result;
23892
23893   arg1 = (Dali::Pixel::Format)jarg1;
23894   {
23895     try {
23896       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23897     } catch (std::out_of_range& e) {
23898       {
23899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23900       };
23901     } catch (std::exception& e) {
23902       {
23903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (Dali::DaliException e) {
23906       {
23907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23908       };
23909     } catch (...) {
23910       {
23911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23912       };
23913     }
23914   }
23915
23916   jresult = result;
23917   return jresult;
23918 }
23919
23920
23921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23922   Dali::Pixel::Format arg1 ;
23923   int *arg2 = 0 ;
23924   int *arg3 = 0 ;
23925
23926   arg1 = (Dali::Pixel::Format)jarg1;
23927   arg2 = (int *)jarg2;
23928   if (!arg2) {
23929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23930     return ;
23931   }
23932   arg3 = (int *)jarg3;
23933   if (!arg3) {
23934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23935     return ;
23936   }
23937   {
23938     try {
23939       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23940     } catch (std::out_of_range& e) {
23941       {
23942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23943       };
23944     } catch (std::exception& e) {
23945       {
23946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23947       };
23948     } catch (Dali::DaliException e) {
23949       {
23950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23951       };
23952     } catch (...) {
23953       {
23954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23955       };
23956     }
23957   }
23958
23959 }
23960
23961
23962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23963   void * jresult ;
23964   unsigned char *arg1 = (unsigned char *) 0 ;
23965   unsigned int arg2 ;
23966   unsigned int arg3 ;
23967   unsigned int arg4 ;
23968   Dali::Pixel::Format arg5 ;
23969   Dali::PixelData::ReleaseFunction arg6 ;
23970   Dali::PixelData result;
23971
23972   arg1 = jarg1;
23973   arg2 = (unsigned int)jarg2;
23974   arg3 = (unsigned int)jarg3;
23975   arg4 = (unsigned int)jarg4;
23976   arg5 = (Dali::Pixel::Format)jarg5;
23977   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23978   {
23979     try {
23980       auto pixelBuffer = new unsigned char[jarg2];
23981       memcpy( pixelBuffer, arg1, arg2);
23982       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23983     } catch (std::out_of_range& e) {
23984       {
23985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23986       };
23987     } catch (std::exception& e) {
23988       {
23989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23990       };
23991     } catch (Dali::DaliException e) {
23992       {
23993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23994       };
23995     } catch (...) {
23996       {
23997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23998       };
23999     }
24000   }
24001
24002   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24003
24004
24005   return jresult;
24006 }
24007
24008
24009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24010   void * jresult ;
24011   Dali::PixelData *result = 0 ;
24012
24013   {
24014     try {
24015       result = (Dali::PixelData *)new Dali::PixelData();
24016     } catch (std::out_of_range& e) {
24017       {
24018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24019       };
24020     } catch (std::exception& e) {
24021       {
24022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24023       };
24024     } catch (Dali::DaliException e) {
24025       {
24026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24027       };
24028     } catch (...) {
24029       {
24030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24031       };
24032     }
24033   }
24034
24035   jresult = (void *)result;
24036   return jresult;
24037 }
24038
24039
24040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24041   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24042
24043   arg1 = (Dali::PixelData *)jarg1;
24044   {
24045     try {
24046       delete arg1;
24047     } catch (std::out_of_range& e) {
24048       {
24049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24050       };
24051     } catch (std::exception& e) {
24052       {
24053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24054       };
24055     } catch (Dali::DaliException e) {
24056       {
24057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24058       };
24059     } catch (...) {
24060       {
24061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24062       };
24063     }
24064   }
24065
24066 }
24067
24068
24069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24070   void * jresult ;
24071   Dali::PixelData *arg1 = 0 ;
24072   Dali::PixelData *result = 0 ;
24073
24074   arg1 = (Dali::PixelData *)jarg1;
24075   if (!arg1) {
24076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24077     return 0;
24078   }
24079   {
24080     try {
24081       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24082     } catch (std::out_of_range& e) {
24083       {
24084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24085       };
24086     } catch (std::exception& e) {
24087       {
24088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24089       };
24090     } catch (Dali::DaliException e) {
24091       {
24092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24093       };
24094     } catch (...) {
24095       {
24096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24097       };
24098     }
24099   }
24100
24101   jresult = (void *)result;
24102   return jresult;
24103 }
24104
24105
24106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24107   void * jresult ;
24108   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24109   Dali::PixelData *arg2 = 0 ;
24110   Dali::PixelData *result = 0 ;
24111
24112   arg1 = (Dali::PixelData *)jarg1;
24113   arg2 = (Dali::PixelData *)jarg2;
24114   if (!arg2) {
24115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24116     return 0;
24117   }
24118   {
24119     try {
24120       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24121     } catch (std::out_of_range& e) {
24122       {
24123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24124       };
24125     } catch (std::exception& e) {
24126       {
24127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24128       };
24129     } catch (Dali::DaliException e) {
24130       {
24131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24132       };
24133     } catch (...) {
24134       {
24135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24136       };
24137     }
24138   }
24139
24140   jresult = (void *)result;
24141   return jresult;
24142 }
24143
24144
24145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24146   unsigned int jresult ;
24147   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24148   unsigned int result;
24149
24150   arg1 = (Dali::PixelData *)jarg1;
24151   {
24152     try {
24153       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24154     } catch (std::out_of_range& e) {
24155       {
24156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24157       };
24158     } catch (std::exception& e) {
24159       {
24160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24161       };
24162     } catch (Dali::DaliException e) {
24163       {
24164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24165       };
24166     } catch (...) {
24167       {
24168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24169       };
24170     }
24171   }
24172
24173   jresult = result;
24174   return jresult;
24175 }
24176
24177
24178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24179   unsigned int jresult ;
24180   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24181   unsigned int result;
24182
24183   arg1 = (Dali::PixelData *)jarg1;
24184   {
24185     try {
24186       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24187     } catch (std::out_of_range& e) {
24188       {
24189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24190       };
24191     } catch (std::exception& e) {
24192       {
24193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24194       };
24195     } catch (Dali::DaliException e) {
24196       {
24197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24198       };
24199     } catch (...) {
24200       {
24201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24202       };
24203     }
24204   }
24205
24206   jresult = result;
24207   return jresult;
24208 }
24209
24210
24211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24212   int jresult ;
24213   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24214   Dali::Pixel::Format result;
24215
24216   arg1 = (Dali::PixelData *)jarg1;
24217   {
24218     try {
24219       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24220     } catch (std::out_of_range& e) {
24221       {
24222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24223       };
24224     } catch (std::exception& e) {
24225       {
24226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24227       };
24228     } catch (Dali::DaliException e) {
24229       {
24230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24231       };
24232     } catch (...) {
24233       {
24234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24235       };
24236     }
24237   }
24238
24239   jresult = (int)result;
24240   return jresult;
24241 }
24242
24243
24244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24245   unsigned int jresult ;
24246   unsigned int result;
24247
24248   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24249   jresult = result;
24250   return jresult;
24251 }
24252
24253
24254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24255   unsigned int jresult ;
24256   unsigned int result;
24257
24258   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24259   jresult = result;
24260   return jresult;
24261 }
24262
24263
24264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24265   unsigned int jresult ;
24266   unsigned int result;
24267
24268   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24269   jresult = result;
24270   return jresult;
24271 }
24272
24273
24274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24275   unsigned int jresult ;
24276   unsigned int result;
24277
24278   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24279   jresult = result;
24280   return jresult;
24281 }
24282
24283
24284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24285   unsigned int jresult ;
24286   unsigned int result;
24287
24288   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24289   jresult = result;
24290   return jresult;
24291 }
24292
24293
24294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24295   unsigned int jresult ;
24296   unsigned int result;
24297
24298   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24299   jresult = result;
24300   return jresult;
24301 }
24302
24303
24304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24305   void * jresult ;
24306   Dali::TextureType::Type arg1 ;
24307   Dali::Pixel::Format arg2 ;
24308   unsigned int arg3 ;
24309   unsigned int arg4 ;
24310   Dali::Texture result;
24311
24312   arg1 = (Dali::TextureType::Type)jarg1;
24313   arg2 = (Dali::Pixel::Format)jarg2;
24314   arg3 = (unsigned int)jarg3;
24315   arg4 = (unsigned int)jarg4;
24316   {
24317     try {
24318       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24319     } catch (std::out_of_range& e) {
24320       {
24321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24322       };
24323     } catch (std::exception& e) {
24324       {
24325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24326       };
24327     } catch (Dali::DaliException e) {
24328       {
24329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24330       };
24331     } catch (...) {
24332       {
24333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24334       };
24335     }
24336   }
24337
24338   jresult = new Dali::Texture((const Dali::Texture &)result);
24339   return jresult;
24340 }
24341
24342
24343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24344   void * jresult ;
24345   NativeImageInterface *arg1 = 0 ;
24346   Dali::Texture result;
24347
24348   arg1 = (NativeImageInterface *)jarg1;
24349   if (!arg1) {
24350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24351     return 0;
24352   }
24353   {
24354     try {
24355       result = Dali::Texture::New(*arg1);
24356     } catch (std::out_of_range& e) {
24357       {
24358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24359       };
24360     } catch (std::exception& e) {
24361       {
24362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24363       };
24364     } catch (Dali::DaliException e) {
24365       {
24366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24367       };
24368     } catch (...) {
24369       {
24370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24371       };
24372     }
24373   }
24374
24375   jresult = new Dali::Texture((const Dali::Texture &)result);
24376   return jresult;
24377 }
24378
24379
24380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24381   void * jresult ;
24382   Dali::Texture *result = 0 ;
24383
24384   {
24385     try {
24386       result = (Dali::Texture *)new Dali::Texture();
24387     } catch (std::out_of_range& e) {
24388       {
24389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24390       };
24391     } catch (std::exception& e) {
24392       {
24393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24394       };
24395     } catch (Dali::DaliException e) {
24396       {
24397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24398       };
24399     } catch (...) {
24400       {
24401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24402       };
24403     }
24404   }
24405
24406   jresult = (void *)result;
24407   return jresult;
24408 }
24409
24410
24411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24412   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24413
24414   arg1 = (Dali::Texture *)jarg1;
24415   {
24416     try {
24417       delete arg1;
24418     } catch (std::out_of_range& e) {
24419       {
24420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24421       };
24422     } catch (std::exception& e) {
24423       {
24424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24425       };
24426     } catch (Dali::DaliException e) {
24427       {
24428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24429       };
24430     } catch (...) {
24431       {
24432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24433       };
24434     }
24435   }
24436
24437 }
24438
24439
24440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24441   void * jresult ;
24442   Dali::Texture *arg1 = 0 ;
24443   Dali::Texture *result = 0 ;
24444
24445   arg1 = (Dali::Texture *)jarg1;
24446   if (!arg1) {
24447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24448     return 0;
24449   }
24450   {
24451     try {
24452       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24453     } catch (std::out_of_range& e) {
24454       {
24455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24456       };
24457     } catch (std::exception& e) {
24458       {
24459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24460       };
24461     } catch (Dali::DaliException e) {
24462       {
24463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24464       };
24465     } catch (...) {
24466       {
24467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24468       };
24469     }
24470   }
24471
24472   jresult = (void *)result;
24473   return jresult;
24474 }
24475
24476
24477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24478   void * jresult ;
24479   Dali::BaseHandle arg1 ;
24480   Dali::BaseHandle *argp1 ;
24481   Dali::Texture result;
24482
24483   argp1 = (Dali::BaseHandle *)jarg1;
24484   if (!argp1) {
24485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24486     return 0;
24487   }
24488   arg1 = *argp1;
24489   {
24490     try {
24491       result = Dali::Texture::DownCast(arg1);
24492     } catch (std::out_of_range& e) {
24493       {
24494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24495       };
24496     } catch (std::exception& e) {
24497       {
24498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24499       };
24500     } catch (Dali::DaliException e) {
24501       {
24502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24503       };
24504     } catch (...) {
24505       {
24506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24507       };
24508     }
24509   }
24510
24511   jresult = new Dali::Texture((const Dali::Texture &)result);
24512   return jresult;
24513 }
24514
24515
24516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24517   void * jresult ;
24518   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24519   Dali::Texture *arg2 = 0 ;
24520   Dali::Texture *result = 0 ;
24521
24522   arg1 = (Dali::Texture *)jarg1;
24523   arg2 = (Dali::Texture *)jarg2;
24524   if (!arg2) {
24525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24526     return 0;
24527   }
24528   {
24529     try {
24530       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24531     } catch (std::out_of_range& e) {
24532       {
24533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24534       };
24535     } catch (std::exception& e) {
24536       {
24537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24538       };
24539     } catch (Dali::DaliException e) {
24540       {
24541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24542       };
24543     } catch (...) {
24544       {
24545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24546       };
24547     }
24548   }
24549
24550   jresult = (void *)result;
24551   return jresult;
24552 }
24553
24554
24555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24556   unsigned int jresult ;
24557   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24558   Dali::PixelData arg2 ;
24559   Dali::PixelData *argp2 ;
24560   bool result;
24561
24562   arg1 = (Dali::Texture *)jarg1;
24563   argp2 = (Dali::PixelData *)jarg2;
24564   if (!argp2) {
24565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24566     return 0;
24567   }
24568   arg2 = *argp2;
24569   {
24570     try {
24571       result = (bool)(arg1)->Upload(arg2);
24572     } catch (std::out_of_range& e) {
24573       {
24574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24575       };
24576     } catch (std::exception& e) {
24577       {
24578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24579       };
24580     } catch (Dali::DaliException e) {
24581       {
24582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24583       };
24584     } catch (...) {
24585       {
24586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24587       };
24588     }
24589   }
24590
24591   jresult = result;
24592   return jresult;
24593 }
24594
24595
24596 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) {
24597   unsigned int jresult ;
24598   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24599   Dali::PixelData arg2 ;
24600   unsigned int arg3 ;
24601   unsigned int arg4 ;
24602   unsigned int arg5 ;
24603   unsigned int arg6 ;
24604   unsigned int arg7 ;
24605   unsigned int arg8 ;
24606   Dali::PixelData *argp2 ;
24607   bool result;
24608
24609   arg1 = (Dali::Texture *)jarg1;
24610   argp2 = (Dali::PixelData *)jarg2;
24611   if (!argp2) {
24612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24613     return 0;
24614   }
24615   arg2 = *argp2;
24616   arg3 = (unsigned int)jarg3;
24617   arg4 = (unsigned int)jarg4;
24618   arg5 = (unsigned int)jarg5;
24619   arg6 = (unsigned int)jarg6;
24620   arg7 = (unsigned int)jarg7;
24621   arg8 = (unsigned int)jarg8;
24622   {
24623     try {
24624       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24625     } catch (std::out_of_range& e) {
24626       {
24627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24628       };
24629     } catch (std::exception& e) {
24630       {
24631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24632       };
24633     } catch (Dali::DaliException e) {
24634       {
24635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24636       };
24637     } catch (...) {
24638       {
24639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24640       };
24641     }
24642   }
24643
24644   jresult = result;
24645   return jresult;
24646 }
24647
24648
24649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24650   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24651
24652   arg1 = (Dali::Texture *)jarg1;
24653   {
24654     try {
24655       (arg1)->GenerateMipmaps();
24656     } catch (std::out_of_range& e) {
24657       {
24658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24659       };
24660     } catch (std::exception& e) {
24661       {
24662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24663       };
24664     } catch (Dali::DaliException e) {
24665       {
24666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24667       };
24668     } catch (...) {
24669       {
24670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24671       };
24672     }
24673   }
24674
24675 }
24676
24677
24678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24679   unsigned int jresult ;
24680   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24681   unsigned int result;
24682
24683   arg1 = (Dali::Texture *)jarg1;
24684   {
24685     try {
24686       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24687     } catch (std::out_of_range& e) {
24688       {
24689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24690       };
24691     } catch (std::exception& e) {
24692       {
24693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24694       };
24695     } catch (Dali::DaliException e) {
24696       {
24697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24698       };
24699     } catch (...) {
24700       {
24701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24702       };
24703     }
24704   }
24705
24706   jresult = result;
24707   return jresult;
24708 }
24709
24710
24711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24712   unsigned int jresult ;
24713   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24714   unsigned int result;
24715
24716   arg1 = (Dali::Texture *)jarg1;
24717   {
24718     try {
24719       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24720     } catch (std::out_of_range& e) {
24721       {
24722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24723       };
24724     } catch (std::exception& e) {
24725       {
24726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24727       };
24728     } catch (Dali::DaliException e) {
24729       {
24730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24731       };
24732     } catch (...) {
24733       {
24734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24735       };
24736     }
24737   }
24738
24739   jresult = result;
24740   return jresult;
24741 }
24742
24743
24744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24745   void * jresult ;
24746   Dali::Sampler result;
24747
24748   {
24749     try {
24750       result = Dali::Sampler::New();
24751     } catch (std::out_of_range& e) {
24752       {
24753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24754       };
24755     } catch (std::exception& e) {
24756       {
24757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24758       };
24759     } catch (Dali::DaliException e) {
24760       {
24761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24762       };
24763     } catch (...) {
24764       {
24765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24766       };
24767     }
24768   }
24769
24770   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24771   return jresult;
24772 }
24773
24774
24775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24776   void * jresult ;
24777   Dali::Sampler *result = 0 ;
24778
24779   {
24780     try {
24781       result = (Dali::Sampler *)new Dali::Sampler();
24782     } catch (std::out_of_range& e) {
24783       {
24784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24785       };
24786     } catch (std::exception& e) {
24787       {
24788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24789       };
24790     } catch (Dali::DaliException e) {
24791       {
24792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24793       };
24794     } catch (...) {
24795       {
24796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24797       };
24798     }
24799   }
24800
24801   jresult = (void *)result;
24802   return jresult;
24803 }
24804
24805
24806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24807   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24808
24809   arg1 = (Dali::Sampler *)jarg1;
24810   {
24811     try {
24812       delete arg1;
24813     } catch (std::out_of_range& e) {
24814       {
24815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24816       };
24817     } catch (std::exception& e) {
24818       {
24819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24820       };
24821     } catch (Dali::DaliException e) {
24822       {
24823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24824       };
24825     } catch (...) {
24826       {
24827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24828       };
24829     }
24830   }
24831
24832 }
24833
24834
24835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24836   void * jresult ;
24837   Dali::Sampler *arg1 = 0 ;
24838   Dali::Sampler *result = 0 ;
24839
24840   arg1 = (Dali::Sampler *)jarg1;
24841   if (!arg1) {
24842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24843     return 0;
24844   }
24845   {
24846     try {
24847       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24848     } catch (std::out_of_range& e) {
24849       {
24850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24851       };
24852     } catch (std::exception& e) {
24853       {
24854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24855       };
24856     } catch (Dali::DaliException e) {
24857       {
24858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24859       };
24860     } catch (...) {
24861       {
24862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24863       };
24864     }
24865   }
24866
24867   jresult = (void *)result;
24868   return jresult;
24869 }
24870
24871
24872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24873   void * jresult ;
24874   Dali::BaseHandle arg1 ;
24875   Dali::BaseHandle *argp1 ;
24876   Dali::Sampler result;
24877
24878   argp1 = (Dali::BaseHandle *)jarg1;
24879   if (!argp1) {
24880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24881     return 0;
24882   }
24883   arg1 = *argp1;
24884   {
24885     try {
24886       result = Dali::Sampler::DownCast(arg1);
24887     } catch (std::out_of_range& e) {
24888       {
24889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24890       };
24891     } catch (std::exception& e) {
24892       {
24893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24894       };
24895     } catch (Dali::DaliException e) {
24896       {
24897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24898       };
24899     } catch (...) {
24900       {
24901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24902       };
24903     }
24904   }
24905
24906   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24907   return jresult;
24908 }
24909
24910
24911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24912   void * jresult ;
24913   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24914   Dali::Sampler *arg2 = 0 ;
24915   Dali::Sampler *result = 0 ;
24916
24917   arg1 = (Dali::Sampler *)jarg1;
24918   arg2 = (Dali::Sampler *)jarg2;
24919   if (!arg2) {
24920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24921     return 0;
24922   }
24923   {
24924     try {
24925       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24926     } catch (std::out_of_range& e) {
24927       {
24928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24929       };
24930     } catch (std::exception& e) {
24931       {
24932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24933       };
24934     } catch (Dali::DaliException e) {
24935       {
24936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24937       };
24938     } catch (...) {
24939       {
24940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24941       };
24942     }
24943   }
24944
24945   jresult = (void *)result;
24946   return jresult;
24947 }
24948
24949
24950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24951   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24952   Dali::FilterMode::Type arg2 ;
24953   Dali::FilterMode::Type arg3 ;
24954
24955   arg1 = (Dali::Sampler *)jarg1;
24956   arg2 = (Dali::FilterMode::Type)jarg2;
24957   arg3 = (Dali::FilterMode::Type)jarg3;
24958   {
24959     try {
24960       (arg1)->SetFilterMode(arg2,arg3);
24961     } catch (std::out_of_range& e) {
24962       {
24963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24964       };
24965     } catch (std::exception& e) {
24966       {
24967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24968       };
24969     } catch (Dali::DaliException e) {
24970       {
24971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24972       };
24973     } catch (...) {
24974       {
24975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24976       };
24977     }
24978   }
24979
24980 }
24981
24982
24983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24984   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24985   Dali::WrapMode::Type arg2 ;
24986   Dali::WrapMode::Type arg3 ;
24987
24988   arg1 = (Dali::Sampler *)jarg1;
24989   arg2 = (Dali::WrapMode::Type)jarg2;
24990   arg3 = (Dali::WrapMode::Type)jarg3;
24991   {
24992     try {
24993       (arg1)->SetWrapMode(arg2,arg3);
24994     } catch (std::out_of_range& e) {
24995       {
24996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24997       };
24998     } catch (std::exception& e) {
24999       {
25000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25001       };
25002     } catch (Dali::DaliException e) {
25003       {
25004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25005       };
25006     } catch (...) {
25007       {
25008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25009       };
25010     }
25011   }
25012
25013 }
25014
25015
25016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25017   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25018   Dali::WrapMode::Type arg2 ;
25019   Dali::WrapMode::Type arg3 ;
25020   Dali::WrapMode::Type arg4 ;
25021
25022   arg1 = (Dali::Sampler *)jarg1;
25023   arg2 = (Dali::WrapMode::Type)jarg2;
25024   arg3 = (Dali::WrapMode::Type)jarg3;
25025   arg4 = (Dali::WrapMode::Type)jarg4;
25026   {
25027     try {
25028       (arg1)->SetWrapMode(arg2,arg3,arg4);
25029     } catch (std::out_of_range& e) {
25030       {
25031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25032       };
25033     } catch (std::exception& e) {
25034       {
25035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25036       };
25037     } catch (Dali::DaliException e) {
25038       {
25039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25040       };
25041     } catch (...) {
25042       {
25043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25044       };
25045     }
25046   }
25047
25048 }
25049
25050
25051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25052   void * jresult ;
25053   Dali::TextureSet result;
25054
25055   {
25056     try {
25057       result = Dali::TextureSet::New();
25058     } catch (std::out_of_range& e) {
25059       {
25060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25061       };
25062     } catch (std::exception& e) {
25063       {
25064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25065       };
25066     } catch (Dali::DaliException e) {
25067       {
25068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25069       };
25070     } catch (...) {
25071       {
25072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25073       };
25074     }
25075   }
25076
25077   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25078   return jresult;
25079 }
25080
25081
25082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25083   void * jresult ;
25084   Dali::TextureSet *result = 0 ;
25085
25086   {
25087     try {
25088       result = (Dali::TextureSet *)new Dali::TextureSet();
25089     } catch (std::out_of_range& e) {
25090       {
25091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25092       };
25093     } catch (std::exception& e) {
25094       {
25095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25096       };
25097     } catch (Dali::DaliException e) {
25098       {
25099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25100       };
25101     } catch (...) {
25102       {
25103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25104       };
25105     }
25106   }
25107
25108   jresult = (void *)result;
25109   return jresult;
25110 }
25111
25112
25113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25114   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25115
25116   arg1 = (Dali::TextureSet *)jarg1;
25117   {
25118     try {
25119       delete arg1;
25120     } catch (std::out_of_range& e) {
25121       {
25122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25123       };
25124     } catch (std::exception& e) {
25125       {
25126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25127       };
25128     } catch (Dali::DaliException e) {
25129       {
25130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25131       };
25132     } catch (...) {
25133       {
25134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25135       };
25136     }
25137   }
25138
25139 }
25140
25141
25142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25143   void * jresult ;
25144   Dali::TextureSet *arg1 = 0 ;
25145   Dali::TextureSet *result = 0 ;
25146
25147   arg1 = (Dali::TextureSet *)jarg1;
25148   if (!arg1) {
25149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25150     return 0;
25151   }
25152   {
25153     try {
25154       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25155     } catch (std::out_of_range& e) {
25156       {
25157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25158       };
25159     } catch (std::exception& e) {
25160       {
25161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25162       };
25163     } catch (Dali::DaliException e) {
25164       {
25165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25166       };
25167     } catch (...) {
25168       {
25169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25170       };
25171     }
25172   }
25173
25174   jresult = (void *)result;
25175   return jresult;
25176 }
25177
25178
25179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25180   void * jresult ;
25181   Dali::BaseHandle arg1 ;
25182   Dali::BaseHandle *argp1 ;
25183   Dali::TextureSet result;
25184
25185   argp1 = (Dali::BaseHandle *)jarg1;
25186   if (!argp1) {
25187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25188     return 0;
25189   }
25190   arg1 = *argp1;
25191   {
25192     try {
25193       result = Dali::TextureSet::DownCast(arg1);
25194     } catch (std::out_of_range& e) {
25195       {
25196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25197       };
25198     } catch (std::exception& e) {
25199       {
25200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25201       };
25202     } catch (Dali::DaliException e) {
25203       {
25204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25205       };
25206     } catch (...) {
25207       {
25208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25209       };
25210     }
25211   }
25212
25213   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25214   return jresult;
25215 }
25216
25217
25218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25219   void * jresult ;
25220   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25221   Dali::TextureSet *arg2 = 0 ;
25222   Dali::TextureSet *result = 0 ;
25223
25224   arg1 = (Dali::TextureSet *)jarg1;
25225   arg2 = (Dali::TextureSet *)jarg2;
25226   if (!arg2) {
25227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25228     return 0;
25229   }
25230   {
25231     try {
25232       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25233     } catch (std::out_of_range& e) {
25234       {
25235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25236       };
25237     } catch (std::exception& e) {
25238       {
25239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25240       };
25241     } catch (Dali::DaliException e) {
25242       {
25243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25244       };
25245     } catch (...) {
25246       {
25247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25248       };
25249     }
25250   }
25251
25252   jresult = (void *)result;
25253   return jresult;
25254 }
25255
25256
25257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25258   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25259   size_t arg2 ;
25260   Dali::Texture arg3 ;
25261   Dali::Texture *argp3 ;
25262
25263   arg1 = (Dali::TextureSet *)jarg1;
25264   arg2 = (size_t)jarg2;
25265   argp3 = (Dali::Texture *)jarg3;
25266   if (!argp3) {
25267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25268     return ;
25269   }
25270   arg3 = *argp3;
25271   {
25272     try {
25273       (arg1)->SetTexture(arg2,arg3);
25274     } catch (std::out_of_range& e) {
25275       {
25276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25277       };
25278     } catch (std::exception& e) {
25279       {
25280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25281       };
25282     } catch (Dali::DaliException e) {
25283       {
25284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25285       };
25286     } catch (...) {
25287       {
25288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25289       };
25290     }
25291   }
25292
25293 }
25294
25295
25296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25297   void * jresult ;
25298   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25299   size_t arg2 ;
25300   Dali::Texture result;
25301
25302   arg1 = (Dali::TextureSet *)jarg1;
25303   arg2 = (size_t)jarg2;
25304   {
25305     try {
25306       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25307     } catch (std::out_of_range& e) {
25308       {
25309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25310       };
25311     } catch (std::exception& e) {
25312       {
25313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25314       };
25315     } catch (Dali::DaliException e) {
25316       {
25317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25318       };
25319     } catch (...) {
25320       {
25321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25322       };
25323     }
25324   }
25325
25326   jresult = new Dali::Texture((const Dali::Texture &)result);
25327   return jresult;
25328 }
25329
25330
25331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25332   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25333   size_t arg2 ;
25334   Dali::Sampler arg3 ;
25335   Dali::Sampler *argp3 ;
25336
25337   arg1 = (Dali::TextureSet *)jarg1;
25338   arg2 = (size_t)jarg2;
25339   argp3 = (Dali::Sampler *)jarg3;
25340   if (!argp3) {
25341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25342     return ;
25343   }
25344   arg3 = *argp3;
25345   {
25346     try {
25347       (arg1)->SetSampler(arg2,arg3);
25348     } catch (std::out_of_range& e) {
25349       {
25350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25351       };
25352     } catch (std::exception& e) {
25353       {
25354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25355       };
25356     } catch (Dali::DaliException e) {
25357       {
25358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25359       };
25360     } catch (...) {
25361       {
25362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25363       };
25364     }
25365   }
25366
25367 }
25368
25369
25370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25371   void * jresult ;
25372   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25373   size_t arg2 ;
25374   Dali::Sampler result;
25375
25376   arg1 = (Dali::TextureSet *)jarg1;
25377   arg2 = (size_t)jarg2;
25378   {
25379     try {
25380       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25381     } catch (std::out_of_range& e) {
25382       {
25383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25384       };
25385     } catch (std::exception& e) {
25386       {
25387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25388       };
25389     } catch (Dali::DaliException e) {
25390       {
25391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25392       };
25393     } catch (...) {
25394       {
25395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25396       };
25397     }
25398   }
25399
25400   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25401   return jresult;
25402 }
25403
25404
25405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25406   unsigned long jresult ;
25407   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25408   size_t result;
25409
25410   arg1 = (Dali::TextureSet *)jarg1;
25411   {
25412     try {
25413       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25414     } catch (std::out_of_range& e) {
25415       {
25416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25417       };
25418     } catch (std::exception& e) {
25419       {
25420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25421       };
25422     } catch (Dali::DaliException e) {
25423       {
25424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25425       };
25426     } catch (...) {
25427       {
25428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25429       };
25430     }
25431   }
25432
25433   jresult = (unsigned long)result;
25434   return jresult;
25435 }
25436
25437
25438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25439   void * jresult ;
25440   Dali::Property::Map *arg1 = 0 ;
25441   Dali::PropertyBuffer result;
25442
25443   arg1 = (Dali::Property::Map *)jarg1;
25444   if (!arg1) {
25445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25446     return 0;
25447   }
25448   {
25449     try {
25450       result = Dali::PropertyBuffer::New(*arg1);
25451     } catch (std::out_of_range& e) {
25452       {
25453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25454       };
25455     } catch (std::exception& e) {
25456       {
25457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25458       };
25459     } catch (Dali::DaliException e) {
25460       {
25461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25462       };
25463     } catch (...) {
25464       {
25465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25466       };
25467     }
25468   }
25469
25470   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25471   return jresult;
25472 }
25473
25474
25475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25476   void * jresult ;
25477   Dali::PropertyBuffer *result = 0 ;
25478
25479   {
25480     try {
25481       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25482     } catch (std::out_of_range& e) {
25483       {
25484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25485       };
25486     } catch (std::exception& e) {
25487       {
25488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25489       };
25490     } catch (Dali::DaliException e) {
25491       {
25492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25493       };
25494     } catch (...) {
25495       {
25496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25497       };
25498     }
25499   }
25500
25501   jresult = (void *)result;
25502   return jresult;
25503 }
25504
25505
25506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25507   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25508
25509   arg1 = (Dali::PropertyBuffer *)jarg1;
25510   {
25511     try {
25512       delete arg1;
25513     } catch (std::out_of_range& e) {
25514       {
25515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25516       };
25517     } catch (std::exception& e) {
25518       {
25519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25520       };
25521     } catch (Dali::DaliException e) {
25522       {
25523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25524       };
25525     } catch (...) {
25526       {
25527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25528       };
25529     }
25530   }
25531
25532 }
25533
25534
25535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25536   void * jresult ;
25537   Dali::PropertyBuffer *arg1 = 0 ;
25538   Dali::PropertyBuffer *result = 0 ;
25539
25540   arg1 = (Dali::PropertyBuffer *)jarg1;
25541   if (!arg1) {
25542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25543     return 0;
25544   }
25545   {
25546     try {
25547       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25548     } catch (std::out_of_range& e) {
25549       {
25550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25551       };
25552     } catch (std::exception& e) {
25553       {
25554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25555       };
25556     } catch (Dali::DaliException e) {
25557       {
25558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25559       };
25560     } catch (...) {
25561       {
25562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25563       };
25564     }
25565   }
25566
25567   jresult = (void *)result;
25568   return jresult;
25569 }
25570
25571
25572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25573   void * jresult ;
25574   Dali::BaseHandle arg1 ;
25575   Dali::BaseHandle *argp1 ;
25576   Dali::PropertyBuffer result;
25577
25578   argp1 = (Dali::BaseHandle *)jarg1;
25579   if (!argp1) {
25580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25581     return 0;
25582   }
25583   arg1 = *argp1;
25584   {
25585     try {
25586       result = Dali::PropertyBuffer::DownCast(arg1);
25587     } catch (std::out_of_range& e) {
25588       {
25589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25590       };
25591     } catch (std::exception& e) {
25592       {
25593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25594       };
25595     } catch (Dali::DaliException e) {
25596       {
25597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25598       };
25599     } catch (...) {
25600       {
25601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25602       };
25603     }
25604   }
25605
25606   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25607   return jresult;
25608 }
25609
25610
25611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25612   void * jresult ;
25613   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25614   Dali::PropertyBuffer *arg2 = 0 ;
25615   Dali::PropertyBuffer *result = 0 ;
25616
25617   arg1 = (Dali::PropertyBuffer *)jarg1;
25618   arg2 = (Dali::PropertyBuffer *)jarg2;
25619   if (!arg2) {
25620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25621     return 0;
25622   }
25623   {
25624     try {
25625       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25626     } catch (std::out_of_range& e) {
25627       {
25628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25629       };
25630     } catch (std::exception& e) {
25631       {
25632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25633       };
25634     } catch (Dali::DaliException e) {
25635       {
25636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25637       };
25638     } catch (...) {
25639       {
25640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25641       };
25642     }
25643   }
25644
25645   jresult = (void *)result;
25646   return jresult;
25647 }
25648
25649
25650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25651   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25652   void *arg2 = (void *) 0 ;
25653   std::size_t arg3 ;
25654
25655   arg1 = (Dali::PropertyBuffer *)jarg1;
25656   arg2 = jarg2;
25657   arg3 = (std::size_t)jarg3;
25658   {
25659     try {
25660       (arg1)->SetData((void const *)arg2,arg3);
25661     } catch (std::out_of_range& e) {
25662       {
25663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25664       };
25665     } catch (std::exception& e) {
25666       {
25667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25668       };
25669     } catch (Dali::DaliException e) {
25670       {
25671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25672       };
25673     } catch (...) {
25674       {
25675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25676       };
25677     }
25678   }
25679
25680 }
25681
25682
25683 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25684   unsigned long jresult ;
25685   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25686   std::size_t result;
25687
25688   arg1 = (Dali::PropertyBuffer *)jarg1;
25689   {
25690     try {
25691       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25692     } catch (std::out_of_range& e) {
25693       {
25694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25695       };
25696     } catch (std::exception& e) {
25697       {
25698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25699       };
25700     } catch (Dali::DaliException e) {
25701       {
25702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25703       };
25704     } catch (...) {
25705       {
25706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25707       };
25708     }
25709   }
25710
25711   jresult = (unsigned long)result;
25712   return jresult;
25713 }
25714
25715
25716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25717   void * jresult ;
25718   Dali::Geometry result;
25719
25720   {
25721     try {
25722       result = Dali::Geometry::New();
25723     } catch (std::out_of_range& e) {
25724       {
25725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25726       };
25727     } catch (std::exception& e) {
25728       {
25729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25730       };
25731     } catch (Dali::DaliException e) {
25732       {
25733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25734       };
25735     } catch (...) {
25736       {
25737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25738       };
25739     }
25740   }
25741
25742   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25743   return jresult;
25744 }
25745
25746
25747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25748   void * jresult ;
25749   Dali::Geometry *result = 0 ;
25750
25751   {
25752     try {
25753       result = (Dali::Geometry *)new Dali::Geometry();
25754     } catch (std::out_of_range& e) {
25755       {
25756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25757       };
25758     } catch (std::exception& e) {
25759       {
25760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25761       };
25762     } catch (Dali::DaliException e) {
25763       {
25764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25765       };
25766     } catch (...) {
25767       {
25768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25769       };
25770     }
25771   }
25772
25773   jresult = (void *)result;
25774   return jresult;
25775 }
25776
25777
25778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25779   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25780
25781   arg1 = (Dali::Geometry *)jarg1;
25782   {
25783     try {
25784       delete arg1;
25785     } catch (std::out_of_range& e) {
25786       {
25787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25788       };
25789     } catch (std::exception& e) {
25790       {
25791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25792       };
25793     } catch (Dali::DaliException e) {
25794       {
25795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25796       };
25797     } catch (...) {
25798       {
25799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25800       };
25801     }
25802   }
25803
25804 }
25805
25806
25807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25808   void * jresult ;
25809   Dali::Geometry *arg1 = 0 ;
25810   Dali::Geometry *result = 0 ;
25811
25812   arg1 = (Dali::Geometry *)jarg1;
25813   if (!arg1) {
25814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25815     return 0;
25816   }
25817   {
25818     try {
25819       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25820     } catch (std::out_of_range& e) {
25821       {
25822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25823       };
25824     } catch (std::exception& e) {
25825       {
25826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25827       };
25828     } catch (Dali::DaliException e) {
25829       {
25830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25831       };
25832     } catch (...) {
25833       {
25834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25835       };
25836     }
25837   }
25838
25839   jresult = (void *)result;
25840   return jresult;
25841 }
25842
25843
25844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25845   void * jresult ;
25846   Dali::BaseHandle arg1 ;
25847   Dali::BaseHandle *argp1 ;
25848   Dali::Geometry result;
25849
25850   argp1 = (Dali::BaseHandle *)jarg1;
25851   if (!argp1) {
25852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25853     return 0;
25854   }
25855   arg1 = *argp1;
25856   {
25857     try {
25858       result = Dali::Geometry::DownCast(arg1);
25859     } catch (std::out_of_range& e) {
25860       {
25861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25862       };
25863     } catch (std::exception& e) {
25864       {
25865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25866       };
25867     } catch (Dali::DaliException e) {
25868       {
25869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25870       };
25871     } catch (...) {
25872       {
25873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25874       };
25875     }
25876   }
25877
25878   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25879   return jresult;
25880 }
25881
25882
25883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25884   void * jresult ;
25885   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25886   Dali::Geometry *arg2 = 0 ;
25887   Dali::Geometry *result = 0 ;
25888
25889   arg1 = (Dali::Geometry *)jarg1;
25890   arg2 = (Dali::Geometry *)jarg2;
25891   if (!arg2) {
25892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25893     return 0;
25894   }
25895   {
25896     try {
25897       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25898     } catch (std::out_of_range& e) {
25899       {
25900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25901       };
25902     } catch (std::exception& e) {
25903       {
25904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25905       };
25906     } catch (Dali::DaliException e) {
25907       {
25908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25909       };
25910     } catch (...) {
25911       {
25912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25913       };
25914     }
25915   }
25916
25917   jresult = (void *)result;
25918   return jresult;
25919 }
25920
25921
25922 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25923   unsigned long jresult ;
25924   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25925   Dali::PropertyBuffer *arg2 = 0 ;
25926   std::size_t result;
25927
25928   arg1 = (Dali::Geometry *)jarg1;
25929   arg2 = (Dali::PropertyBuffer *)jarg2;
25930   if (!arg2) {
25931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25932     return 0;
25933   }
25934   {
25935     try {
25936       result = (arg1)->AddVertexBuffer(*arg2);
25937     } catch (std::out_of_range& e) {
25938       {
25939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25940       };
25941     } catch (std::exception& e) {
25942       {
25943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25944       };
25945     } catch (Dali::DaliException e) {
25946       {
25947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25948       };
25949     } catch (...) {
25950       {
25951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25952       };
25953     }
25954   }
25955
25956   jresult = (unsigned long)result;
25957   return jresult;
25958 }
25959
25960
25961 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25962   unsigned long jresult ;
25963   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25964   std::size_t result;
25965
25966   arg1 = (Dali::Geometry *)jarg1;
25967   {
25968     try {
25969       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25970     } catch (std::out_of_range& e) {
25971       {
25972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25973       };
25974     } catch (std::exception& e) {
25975       {
25976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25977       };
25978     } catch (Dali::DaliException e) {
25979       {
25980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25981       };
25982     } catch (...) {
25983       {
25984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25985       };
25986     }
25987   }
25988
25989   jresult = (unsigned long)result;
25990   return jresult;
25991 }
25992
25993
25994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25995   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25996   std::size_t arg2 ;
25997
25998   arg1 = (Dali::Geometry *)jarg1;
25999   arg2 = (std::size_t)jarg2;
26000   {
26001     try {
26002       (arg1)->RemoveVertexBuffer(arg2);
26003     } catch (std::out_of_range& e) {
26004       {
26005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26006       };
26007     } catch (std::exception& e) {
26008       {
26009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26010       };
26011     } catch (Dali::DaliException e) {
26012       {
26013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26014       };
26015     } catch (...) {
26016       {
26017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26018       };
26019     }
26020   }
26021
26022 }
26023
26024
26025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26026   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26027   unsigned short *arg2 = (unsigned short *) 0 ;
26028   size_t arg3 ;
26029
26030   arg1 = (Dali::Geometry *)jarg1;
26031   arg2 = jarg2;
26032   arg3 = (size_t)jarg3;
26033   {
26034     try {
26035       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26036     } catch (std::out_of_range& e) {
26037       {
26038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26039       };
26040     } catch (std::exception& e) {
26041       {
26042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26043       };
26044     } catch (Dali::DaliException e) {
26045       {
26046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26047       };
26048     } catch (...) {
26049       {
26050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26051       };
26052     }
26053   }
26054
26055
26056
26057 }
26058
26059
26060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26061   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26062   Dali::Geometry::Type arg2 ;
26063
26064   arg1 = (Dali::Geometry *)jarg1;
26065   arg2 = (Dali::Geometry::Type)jarg2;
26066   {
26067     try {
26068       (arg1)->SetType(arg2);
26069     } catch (std::out_of_range& e) {
26070       {
26071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26072       };
26073     } catch (std::exception& e) {
26074       {
26075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26076       };
26077     } catch (Dali::DaliException e) {
26078       {
26079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26080       };
26081     } catch (...) {
26082       {
26083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26084       };
26085     }
26086   }
26087
26088 }
26089
26090
26091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26092   int jresult ;
26093   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26094   Dali::Geometry::Type result;
26095
26096   arg1 = (Dali::Geometry *)jarg1;
26097   {
26098     try {
26099       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26100     } catch (std::out_of_range& e) {
26101       {
26102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26103       };
26104     } catch (std::exception& e) {
26105       {
26106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26107       };
26108     } catch (Dali::DaliException e) {
26109       {
26110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26111       };
26112     } catch (...) {
26113       {
26114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26115       };
26116     }
26117   }
26118
26119   jresult = (int)result;
26120   return jresult;
26121 }
26122
26123
26124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26125   void * jresult ;
26126   Dali::Shader::Hint *result = 0 ;
26127
26128   {
26129     try {
26130       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26131     } catch (std::out_of_range& e) {
26132       {
26133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26134       };
26135     } catch (std::exception& e) {
26136       {
26137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26138       };
26139     } catch (Dali::DaliException e) {
26140       {
26141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26142       };
26143     } catch (...) {
26144       {
26145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26146       };
26147     }
26148   }
26149
26150   jresult = (void *)result;
26151   return jresult;
26152 }
26153
26154
26155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26156   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26157
26158   arg1 = (Dali::Shader::Hint *)jarg1;
26159   {
26160     try {
26161       delete arg1;
26162     } catch (std::out_of_range& e) {
26163       {
26164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26165       };
26166     } catch (std::exception& e) {
26167       {
26168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26169       };
26170     } catch (Dali::DaliException e) {
26171       {
26172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26173       };
26174     } catch (...) {
26175       {
26176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26177       };
26178     }
26179   }
26180
26181 }
26182
26183
26184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26185   int jresult ;
26186   int result;
26187
26188   result = (int)Dali::Shader::Property::PROGRAM;
26189   jresult = (int)result;
26190   return jresult;
26191 }
26192
26193
26194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26195   void * jresult ;
26196   Dali::Shader::Property *result = 0 ;
26197
26198   {
26199     try {
26200       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26201     } catch (std::out_of_range& e) {
26202       {
26203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26204       };
26205     } catch (std::exception& e) {
26206       {
26207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26208       };
26209     } catch (Dali::DaliException e) {
26210       {
26211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26212       };
26213     } catch (...) {
26214       {
26215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26216       };
26217     }
26218   }
26219
26220   jresult = (void *)result;
26221   return jresult;
26222 }
26223
26224
26225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26226   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26227
26228   arg1 = (Dali::Shader::Property *)jarg1;
26229   {
26230     try {
26231       delete arg1;
26232     } catch (std::out_of_range& e) {
26233       {
26234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26235       };
26236     } catch (std::exception& e) {
26237       {
26238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26239       };
26240     } catch (Dali::DaliException e) {
26241       {
26242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26243       };
26244     } catch (...) {
26245       {
26246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26247       };
26248     }
26249   }
26250
26251 }
26252
26253
26254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26255   void * jresult ;
26256   std::string *arg1 = 0 ;
26257   std::string *arg2 = 0 ;
26258   Dali::Shader::Hint::Value arg3 ;
26259   Dali::Shader result;
26260
26261   if (!jarg1) {
26262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26263     return 0;
26264   }
26265   std::string arg1_str(jarg1);
26266   arg1 = &arg1_str;
26267   if (!jarg2) {
26268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26269     return 0;
26270   }
26271   std::string arg2_str(jarg2);
26272   arg2 = &arg2_str;
26273   arg3 = (Dali::Shader::Hint::Value)jarg3;
26274   {
26275     try {
26276       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26277     } catch (std::out_of_range& e) {
26278       {
26279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26280       };
26281     } catch (std::exception& e) {
26282       {
26283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26284       };
26285     } catch (Dali::DaliException e) {
26286       {
26287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26288       };
26289     } catch (...) {
26290       {
26291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26292       };
26293     }
26294   }
26295
26296   jresult = new Dali::Shader((const Dali::Shader &)result);
26297
26298   //argout typemap for const std::string&
26299
26300
26301   //argout typemap for const std::string&
26302
26303   return jresult;
26304 }
26305
26306
26307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26308   void * jresult ;
26309   std::string *arg1 = 0 ;
26310   std::string *arg2 = 0 ;
26311   Dali::Shader result;
26312
26313   if (!jarg1) {
26314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26315     return 0;
26316   }
26317   std::string arg1_str(jarg1);
26318   arg1 = &arg1_str;
26319   if (!jarg2) {
26320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26321     return 0;
26322   }
26323   std::string arg2_str(jarg2);
26324   arg2 = &arg2_str;
26325   {
26326     try {
26327       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26328     } catch (std::out_of_range& e) {
26329       {
26330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26331       };
26332     } catch (std::exception& e) {
26333       {
26334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26335       };
26336     } catch (Dali::DaliException e) {
26337       {
26338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26339       };
26340     } catch (...) {
26341       {
26342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26343       };
26344     }
26345   }
26346
26347   jresult = new Dali::Shader((const Dali::Shader &)result);
26348
26349   //argout typemap for const std::string&
26350
26351
26352   //argout typemap for const std::string&
26353
26354   return jresult;
26355 }
26356
26357
26358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26359   void * jresult ;
26360   Dali::Shader *result = 0 ;
26361
26362   {
26363     try {
26364       result = (Dali::Shader *)new Dali::Shader();
26365     } catch (std::out_of_range& e) {
26366       {
26367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26368       };
26369     } catch (std::exception& e) {
26370       {
26371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26372       };
26373     } catch (Dali::DaliException e) {
26374       {
26375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26376       };
26377     } catch (...) {
26378       {
26379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26380       };
26381     }
26382   }
26383
26384   jresult = (void *)result;
26385   return jresult;
26386 }
26387
26388
26389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26390   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26391
26392   arg1 = (Dali::Shader *)jarg1;
26393   {
26394     try {
26395       delete arg1;
26396     } catch (std::out_of_range& e) {
26397       {
26398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26399       };
26400     } catch (std::exception& e) {
26401       {
26402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26403       };
26404     } catch (Dali::DaliException e) {
26405       {
26406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26407       };
26408     } catch (...) {
26409       {
26410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26411       };
26412     }
26413   }
26414
26415 }
26416
26417
26418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26419   void * jresult ;
26420   Dali::Shader *arg1 = 0 ;
26421   Dali::Shader *result = 0 ;
26422
26423   arg1 = (Dali::Shader *)jarg1;
26424   if (!arg1) {
26425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26426     return 0;
26427   }
26428   {
26429     try {
26430       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26431     } catch (std::out_of_range& e) {
26432       {
26433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26434       };
26435     } catch (std::exception& e) {
26436       {
26437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26438       };
26439     } catch (Dali::DaliException e) {
26440       {
26441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26442       };
26443     } catch (...) {
26444       {
26445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26446       };
26447     }
26448   }
26449
26450   jresult = (void *)result;
26451   return jresult;
26452 }
26453
26454
26455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26456   void * jresult ;
26457   Dali::BaseHandle arg1 ;
26458   Dali::BaseHandle *argp1 ;
26459   Dali::Shader result;
26460
26461   argp1 = (Dali::BaseHandle *)jarg1;
26462   if (!argp1) {
26463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26464     return 0;
26465   }
26466   arg1 = *argp1;
26467   {
26468     try {
26469       result = Dali::Shader::DownCast(arg1);
26470     } catch (std::out_of_range& e) {
26471       {
26472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26473       };
26474     } catch (std::exception& e) {
26475       {
26476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26477       };
26478     } catch (Dali::DaliException e) {
26479       {
26480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26481       };
26482     } catch (...) {
26483       {
26484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26485       };
26486     }
26487   }
26488
26489   jresult = new Dali::Shader((const Dali::Shader &)result);
26490   return jresult;
26491 }
26492
26493
26494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26495   void * jresult ;
26496   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26497   Dali::Shader *arg2 = 0 ;
26498   Dali::Shader *result = 0 ;
26499
26500   arg1 = (Dali::Shader *)jarg1;
26501   arg2 = (Dali::Shader *)jarg2;
26502   if (!arg2) {
26503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26504     return 0;
26505   }
26506   {
26507     try {
26508       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26509     } catch (std::out_of_range& e) {
26510       {
26511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26512       };
26513     } catch (std::exception& e) {
26514       {
26515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26516       };
26517     } catch (Dali::DaliException e) {
26518       {
26519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26520       };
26521     } catch (...) {
26522       {
26523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26524       };
26525     }
26526   }
26527
26528   jresult = (void *)result;
26529   return jresult;
26530 }
26531
26532
26533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26534   int jresult ;
26535   int result;
26536
26537   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26538   jresult = (int)result;
26539   return jresult;
26540 }
26541
26542
26543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26544   int jresult ;
26545   int result;
26546
26547   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26548   jresult = (int)result;
26549   return jresult;
26550 }
26551
26552
26553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26554   int jresult ;
26555   int result;
26556
26557   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26558   jresult = (int)result;
26559   return jresult;
26560 }
26561
26562
26563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26564   int jresult ;
26565   int result;
26566
26567   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26568   jresult = (int)result;
26569   return jresult;
26570 }
26571
26572
26573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26574   int jresult ;
26575   int result;
26576
26577   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26578   jresult = (int)result;
26579   return jresult;
26580 }
26581
26582
26583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26584   int jresult ;
26585   int result;
26586
26587   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26588   jresult = (int)result;
26589   return jresult;
26590 }
26591
26592
26593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26594   int jresult ;
26595   int result;
26596
26597   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26598   jresult = (int)result;
26599   return jresult;
26600 }
26601
26602
26603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26604   int jresult ;
26605   int result;
26606
26607   result = (int)Dali::Renderer::Property::BLEND_MODE;
26608   jresult = (int)result;
26609   return jresult;
26610 }
26611
26612
26613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26614   int jresult ;
26615   int result;
26616
26617   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26618   jresult = (int)result;
26619   return jresult;
26620 }
26621
26622
26623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26624   int jresult ;
26625   int result;
26626
26627   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26628   jresult = (int)result;
26629   return jresult;
26630 }
26631
26632
26633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26634   int jresult ;
26635   int result;
26636
26637   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26638   jresult = (int)result;
26639   return jresult;
26640 }
26641
26642
26643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26644   int jresult ;
26645   int result;
26646
26647   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26648   jresult = (int)result;
26649   return jresult;
26650 }
26651
26652
26653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26654   int jresult ;
26655   int result;
26656
26657   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26658   jresult = (int)result;
26659   return jresult;
26660 }
26661
26662
26663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26664   int jresult ;
26665   int result;
26666
26667   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26668   jresult = (int)result;
26669   return jresult;
26670 }
26671
26672
26673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26674   int jresult ;
26675   int result;
26676
26677   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26678   jresult = (int)result;
26679   return jresult;
26680 }
26681
26682
26683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26684   int jresult ;
26685   int result;
26686
26687   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26688   jresult = (int)result;
26689   return jresult;
26690 }
26691
26692
26693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26694   int jresult ;
26695   int result;
26696
26697   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26698   jresult = (int)result;
26699   return jresult;
26700 }
26701
26702
26703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26704   int jresult ;
26705   int result;
26706
26707   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26708   jresult = (int)result;
26709   return jresult;
26710 }
26711
26712
26713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26714   int jresult ;
26715   int result;
26716
26717   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26718   jresult = (int)result;
26719   return jresult;
26720 }
26721
26722
26723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26724   int jresult ;
26725   int result;
26726
26727   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26728   jresult = (int)result;
26729   return jresult;
26730 }
26731
26732
26733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26734   int jresult ;
26735   int result;
26736
26737   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26738   jresult = (int)result;
26739   return jresult;
26740 }
26741
26742
26743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26744   int jresult ;
26745   int result;
26746
26747   result = (int)Dali::Renderer::Property::RENDER_MODE;
26748   jresult = (int)result;
26749   return jresult;
26750 }
26751
26752
26753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26754   int jresult ;
26755   int result;
26756
26757   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26758   jresult = (int)result;
26759   return jresult;
26760 }
26761
26762
26763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26764   int jresult ;
26765   int result;
26766
26767   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26768   jresult = (int)result;
26769   return jresult;
26770 }
26771
26772
26773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26774   int jresult ;
26775   int result;
26776
26777   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26778   jresult = (int)result;
26779   return jresult;
26780 }
26781
26782
26783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26784   int jresult ;
26785   int result;
26786
26787   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26788   jresult = (int)result;
26789   return jresult;
26790 }
26791
26792
26793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26794   int jresult ;
26795   int result;
26796
26797   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26798   jresult = (int)result;
26799   return jresult;
26800 }
26801
26802
26803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26804   int jresult ;
26805   int result;
26806
26807   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26808   jresult = (int)result;
26809   return jresult;
26810 }
26811
26812
26813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26814   int jresult ;
26815   int result;
26816
26817   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26818   jresult = (int)result;
26819   return jresult;
26820 }
26821
26822
26823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26824   void * jresult ;
26825   Dali::Renderer::Property *result = 0 ;
26826
26827   {
26828     try {
26829       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26830     } catch (std::out_of_range& e) {
26831       {
26832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26833       };
26834     } catch (std::exception& e) {
26835       {
26836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26837       };
26838     } catch (Dali::DaliException e) {
26839       {
26840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26841       };
26842     } catch (...) {
26843       {
26844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26845       };
26846     }
26847   }
26848
26849   jresult = (void *)result;
26850   return jresult;
26851 }
26852
26853
26854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26855   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26856
26857   arg1 = (Dali::Renderer::Property *)jarg1;
26858   {
26859     try {
26860       delete arg1;
26861     } catch (std::out_of_range& e) {
26862       {
26863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26864       };
26865     } catch (std::exception& e) {
26866       {
26867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26868       };
26869     } catch (Dali::DaliException e) {
26870       {
26871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26872       };
26873     } catch (...) {
26874       {
26875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26876       };
26877     }
26878   }
26879
26880 }
26881
26882
26883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26884   void * jresult ;
26885   Dali::Geometry *arg1 = 0 ;
26886   Dali::Shader *arg2 = 0 ;
26887   Dali::Renderer result;
26888
26889   arg1 = (Dali::Geometry *)jarg1;
26890   if (!arg1) {
26891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26892     return 0;
26893   }
26894   arg2 = (Dali::Shader *)jarg2;
26895   if (!arg2) {
26896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26897     return 0;
26898   }
26899   {
26900     try {
26901       result = Dali::Renderer::New(*arg1,*arg2);
26902     } catch (std::out_of_range& e) {
26903       {
26904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26905       };
26906     } catch (std::exception& e) {
26907       {
26908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26909       };
26910     } catch (Dali::DaliException e) {
26911       {
26912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26913       };
26914     } catch (...) {
26915       {
26916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26917       };
26918     }
26919   }
26920
26921   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26922   return jresult;
26923 }
26924
26925
26926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26927   void * jresult ;
26928   Dali::Renderer *result = 0 ;
26929
26930   {
26931     try {
26932       result = (Dali::Renderer *)new Dali::Renderer();
26933     } catch (std::out_of_range& e) {
26934       {
26935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26936       };
26937     } catch (std::exception& e) {
26938       {
26939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26940       };
26941     } catch (Dali::DaliException e) {
26942       {
26943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26944       };
26945     } catch (...) {
26946       {
26947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26948       };
26949     }
26950   }
26951
26952   jresult = (void *)result;
26953   return jresult;
26954 }
26955
26956
26957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26958   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26959
26960   arg1 = (Dali::Renderer *)jarg1;
26961   {
26962     try {
26963       delete arg1;
26964     } catch (std::out_of_range& e) {
26965       {
26966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26967       };
26968     } catch (std::exception& e) {
26969       {
26970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26971       };
26972     } catch (Dali::DaliException e) {
26973       {
26974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26975       };
26976     } catch (...) {
26977       {
26978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26979       };
26980     }
26981   }
26982
26983 }
26984
26985
26986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26987   void * jresult ;
26988   Dali::Renderer *arg1 = 0 ;
26989   Dali::Renderer *result = 0 ;
26990
26991   arg1 = (Dali::Renderer *)jarg1;
26992   if (!arg1) {
26993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26994     return 0;
26995   }
26996   {
26997     try {
26998       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26999     } catch (std::out_of_range& e) {
27000       {
27001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27002       };
27003     } catch (std::exception& e) {
27004       {
27005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27006       };
27007     } catch (Dali::DaliException e) {
27008       {
27009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27010       };
27011     } catch (...) {
27012       {
27013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27014       };
27015     }
27016   }
27017
27018   jresult = (void *)result;
27019   return jresult;
27020 }
27021
27022
27023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27024   void * jresult ;
27025   Dali::BaseHandle arg1 ;
27026   Dali::BaseHandle *argp1 ;
27027   Dali::Renderer result;
27028
27029   argp1 = (Dali::BaseHandle *)jarg1;
27030   if (!argp1) {
27031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27032     return 0;
27033   }
27034   arg1 = *argp1;
27035   {
27036     try {
27037       result = Dali::Renderer::DownCast(arg1);
27038     } catch (std::out_of_range& e) {
27039       {
27040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27041       };
27042     } catch (std::exception& e) {
27043       {
27044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27045       };
27046     } catch (Dali::DaliException e) {
27047       {
27048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27049       };
27050     } catch (...) {
27051       {
27052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27053       };
27054     }
27055   }
27056
27057   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27058   return jresult;
27059 }
27060
27061
27062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27063   void * jresult ;
27064   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27065   Dali::Renderer *arg2 = 0 ;
27066   Dali::Renderer *result = 0 ;
27067
27068   arg1 = (Dali::Renderer *)jarg1;
27069   arg2 = (Dali::Renderer *)jarg2;
27070   if (!arg2) {
27071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27072     return 0;
27073   }
27074   {
27075     try {
27076       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27077     } catch (std::out_of_range& e) {
27078       {
27079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27080       };
27081     } catch (std::exception& e) {
27082       {
27083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27084       };
27085     } catch (Dali::DaliException e) {
27086       {
27087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27088       };
27089     } catch (...) {
27090       {
27091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27092       };
27093     }
27094   }
27095
27096   jresult = (void *)result;
27097   return jresult;
27098 }
27099
27100
27101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27102   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27103   Dali::Geometry *arg2 = 0 ;
27104
27105   arg1 = (Dali::Renderer *)jarg1;
27106   arg2 = (Dali::Geometry *)jarg2;
27107   if (!arg2) {
27108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27109     return ;
27110   }
27111   {
27112     try {
27113       (arg1)->SetGeometry(*arg2);
27114     } catch (std::out_of_range& e) {
27115       {
27116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27117       };
27118     } catch (std::exception& e) {
27119       {
27120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27121       };
27122     } catch (Dali::DaliException e) {
27123       {
27124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27125       };
27126     } catch (...) {
27127       {
27128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27129       };
27130     }
27131   }
27132
27133 }
27134
27135
27136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27137   void * jresult ;
27138   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27139   Dali::Geometry result;
27140
27141   arg1 = (Dali::Renderer *)jarg1;
27142   {
27143     try {
27144       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27145     } catch (std::out_of_range& e) {
27146       {
27147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27148       };
27149     } catch (std::exception& e) {
27150       {
27151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27152       };
27153     } catch (Dali::DaliException e) {
27154       {
27155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27156       };
27157     } catch (...) {
27158       {
27159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27160       };
27161     }
27162   }
27163
27164   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27165   return jresult;
27166 }
27167
27168
27169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27170   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27171   int arg2 ;
27172   int arg3 ;
27173
27174   arg1 = (Dali::Renderer *)jarg1;
27175   arg2 = (int)jarg2;
27176   arg3 = (int)jarg3;
27177   {
27178     try {
27179       (arg1)->SetIndexRange(arg2,arg3);
27180     } catch (std::out_of_range& e) {
27181       {
27182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27183       };
27184     } catch (std::exception& e) {
27185       {
27186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27187       };
27188     } catch (Dali::DaliException e) {
27189       {
27190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27191       };
27192     } catch (...) {
27193       {
27194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27195       };
27196     }
27197   }
27198
27199 }
27200
27201
27202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27203   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27204   Dali::TextureSet *arg2 = 0 ;
27205
27206   arg1 = (Dali::Renderer *)jarg1;
27207   arg2 = (Dali::TextureSet *)jarg2;
27208   if (!arg2) {
27209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27210     return ;
27211   }
27212   {
27213     try {
27214       (arg1)->SetTextures(*arg2);
27215     } catch (std::out_of_range& e) {
27216       {
27217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27218       };
27219     } catch (std::exception& e) {
27220       {
27221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27222       };
27223     } catch (Dali::DaliException e) {
27224       {
27225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27226       };
27227     } catch (...) {
27228       {
27229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27230       };
27231     }
27232   }
27233
27234 }
27235
27236
27237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27238   void * jresult ;
27239   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27240   Dali::TextureSet result;
27241
27242   arg1 = (Dali::Renderer *)jarg1;
27243   {
27244     try {
27245       result = ((Dali::Renderer const *)arg1)->GetTextures();
27246     } catch (std::out_of_range& e) {
27247       {
27248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27249       };
27250     } catch (std::exception& e) {
27251       {
27252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27253       };
27254     } catch (Dali::DaliException e) {
27255       {
27256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27257       };
27258     } catch (...) {
27259       {
27260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27261       };
27262     }
27263   }
27264
27265   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27266   return jresult;
27267 }
27268
27269
27270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27271   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27272   Dali::Shader *arg2 = 0 ;
27273
27274   arg1 = (Dali::Renderer *)jarg1;
27275   arg2 = (Dali::Shader *)jarg2;
27276   if (!arg2) {
27277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27278     return ;
27279   }
27280   {
27281     try {
27282       (arg1)->SetShader(*arg2);
27283     } catch (std::out_of_range& e) {
27284       {
27285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27286       };
27287     } catch (std::exception& e) {
27288       {
27289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27290       };
27291     } catch (Dali::DaliException e) {
27292       {
27293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27294       };
27295     } catch (...) {
27296       {
27297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27298       };
27299     }
27300   }
27301
27302 }
27303
27304
27305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27306   void * jresult ;
27307   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27308   Dali::Shader result;
27309
27310   arg1 = (Dali::Renderer *)jarg1;
27311   {
27312     try {
27313       result = ((Dali::Renderer const *)arg1)->GetShader();
27314     } catch (std::out_of_range& e) {
27315       {
27316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27317       };
27318     } catch (std::exception& e) {
27319       {
27320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27321       };
27322     } catch (Dali::DaliException e) {
27323       {
27324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27325       };
27326     } catch (...) {
27327       {
27328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27329       };
27330     }
27331   }
27332
27333   jresult = new Dali::Shader((const Dali::Shader &)result);
27334   return jresult;
27335 }
27336
27337
27338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27339   void * jresult ;
27340   Dali::FrameBuffer::Attachment *result = 0 ;
27341
27342   {
27343     try {
27344       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27345     } catch (std::out_of_range& e) {
27346       {
27347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27348       };
27349     } catch (std::exception& e) {
27350       {
27351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27352       };
27353     } catch (Dali::DaliException e) {
27354       {
27355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27356       };
27357     } catch (...) {
27358       {
27359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27360       };
27361     }
27362   }
27363
27364   jresult = (void *)result;
27365   return jresult;
27366 }
27367
27368
27369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27370   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27371
27372   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27373   {
27374     try {
27375       delete arg1;
27376     } catch (std::out_of_range& e) {
27377       {
27378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27379       };
27380     } catch (std::exception& e) {
27381       {
27382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27383       };
27384     } catch (Dali::DaliException e) {
27385       {
27386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27387       };
27388     } catch (...) {
27389       {
27390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27391       };
27392     }
27393   }
27394
27395 }
27396
27397
27398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27399   void * jresult ;
27400   unsigned int arg1 ;
27401   unsigned int arg2 ;
27402   unsigned int arg3 ;
27403   Dali::FrameBuffer result;
27404
27405   arg1 = (unsigned int)jarg1;
27406   arg2 = (unsigned int)jarg2;
27407   arg3 = (unsigned int)jarg3;
27408   {
27409     try {
27410       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27411     } catch (std::out_of_range& e) {
27412       {
27413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27414       };
27415     } catch (std::exception& e) {
27416       {
27417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27418       };
27419     } catch (Dali::DaliException e) {
27420       {
27421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27422       };
27423     } catch (...) {
27424       {
27425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27426       };
27427     }
27428   }
27429
27430   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27431   return jresult;
27432 }
27433
27434
27435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27436   void * jresult ;
27437   Dali::FrameBuffer *result = 0 ;
27438
27439   {
27440     try {
27441       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27442     } catch (std::out_of_range& e) {
27443       {
27444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27445       };
27446     } catch (std::exception& e) {
27447       {
27448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27449       };
27450     } catch (Dali::DaliException e) {
27451       {
27452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27453       };
27454     } catch (...) {
27455       {
27456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27457       };
27458     }
27459   }
27460
27461   jresult = (void *)result;
27462   return jresult;
27463 }
27464
27465
27466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27467   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27468
27469   arg1 = (Dali::FrameBuffer *)jarg1;
27470   {
27471     try {
27472       delete arg1;
27473     } catch (std::out_of_range& e) {
27474       {
27475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27476       };
27477     } catch (std::exception& e) {
27478       {
27479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27480       };
27481     } catch (Dali::DaliException e) {
27482       {
27483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27484       };
27485     } catch (...) {
27486       {
27487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27488       };
27489     }
27490   }
27491
27492 }
27493
27494
27495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27496   void * jresult ;
27497   Dali::FrameBuffer *arg1 = 0 ;
27498   Dali::FrameBuffer *result = 0 ;
27499
27500   arg1 = (Dali::FrameBuffer *)jarg1;
27501   if (!arg1) {
27502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27503     return 0;
27504   }
27505   {
27506     try {
27507       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27508     } catch (std::out_of_range& e) {
27509       {
27510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27511       };
27512     } catch (std::exception& e) {
27513       {
27514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27515       };
27516     } catch (Dali::DaliException e) {
27517       {
27518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27519       };
27520     } catch (...) {
27521       {
27522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27523       };
27524     }
27525   }
27526
27527   jresult = (void *)result;
27528   return jresult;
27529 }
27530
27531
27532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27533   void * jresult ;
27534   Dali::BaseHandle arg1 ;
27535   Dali::BaseHandle *argp1 ;
27536   Dali::FrameBuffer result;
27537
27538   argp1 = (Dali::BaseHandle *)jarg1;
27539   if (!argp1) {
27540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27541     return 0;
27542   }
27543   arg1 = *argp1;
27544   {
27545     try {
27546       result = Dali::FrameBuffer::DownCast(arg1);
27547     } catch (std::out_of_range& e) {
27548       {
27549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27550       };
27551     } catch (std::exception& e) {
27552       {
27553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27554       };
27555     } catch (Dali::DaliException e) {
27556       {
27557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27558       };
27559     } catch (...) {
27560       {
27561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27562       };
27563     }
27564   }
27565
27566   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27567   return jresult;
27568 }
27569
27570
27571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27572   void * jresult ;
27573   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27574   Dali::FrameBuffer *arg2 = 0 ;
27575   Dali::FrameBuffer *result = 0 ;
27576
27577   arg1 = (Dali::FrameBuffer *)jarg1;
27578   arg2 = (Dali::FrameBuffer *)jarg2;
27579   if (!arg2) {
27580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27581     return 0;
27582   }
27583   {
27584     try {
27585       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27586     } catch (std::out_of_range& e) {
27587       {
27588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27589       };
27590     } catch (std::exception& e) {
27591       {
27592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27593       };
27594     } catch (Dali::DaliException e) {
27595       {
27596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27597       };
27598     } catch (...) {
27599       {
27600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27601       };
27602     }
27603   }
27604
27605   jresult = (void *)result;
27606   return jresult;
27607 }
27608
27609
27610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27611   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27612   Dali::Texture *arg2 = 0 ;
27613
27614   arg1 = (Dali::FrameBuffer *)jarg1;
27615   arg2 = (Dali::Texture *)jarg2;
27616   if (!arg2) {
27617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27618     return ;
27619   }
27620   {
27621     try {
27622       (arg1)->AttachColorTexture(*arg2);
27623     } catch (std::out_of_range& e) {
27624       {
27625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27626       };
27627     } catch (std::exception& e) {
27628       {
27629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27630       };
27631     } catch (Dali::DaliException e) {
27632       {
27633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27634       };
27635     } catch (...) {
27636       {
27637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27638       };
27639     }
27640   }
27641
27642 }
27643
27644
27645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27646   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27647   Dali::Texture *arg2 = 0 ;
27648   unsigned int arg3 ;
27649   unsigned int arg4 ;
27650
27651   arg1 = (Dali::FrameBuffer *)jarg1;
27652   arg2 = (Dali::Texture *)jarg2;
27653   if (!arg2) {
27654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27655     return ;
27656   }
27657   arg3 = (unsigned int)jarg3;
27658   arg4 = (unsigned int)jarg4;
27659   {
27660     try {
27661       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27662     } catch (std::out_of_range& e) {
27663       {
27664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27665       };
27666     } catch (std::exception& e) {
27667       {
27668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27669       };
27670     } catch (Dali::DaliException e) {
27671       {
27672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27673       };
27674     } catch (...) {
27675       {
27676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27677       };
27678     }
27679   }
27680
27681 }
27682
27683
27684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27685   void * jresult ;
27686   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27687   Dali::Texture result;
27688
27689   arg1 = (Dali::FrameBuffer *)jarg1;
27690   {
27691     try {
27692       result = (arg1)->GetColorTexture();
27693     } catch (std::out_of_range& e) {
27694       {
27695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27696       };
27697     } catch (std::exception& e) {
27698       {
27699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27700       };
27701     } catch (Dali::DaliException e) {
27702       {
27703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27704       };
27705     } catch (...) {
27706       {
27707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27708       };
27709     }
27710   }
27711
27712   jresult = new Dali::Texture((const Dali::Texture &)result);
27713   return jresult;
27714 }
27715
27716
27717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27718   void * jresult ;
27719   Dali::RenderTaskList *result = 0 ;
27720
27721   {
27722     try {
27723       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27724     } catch (std::out_of_range& e) {
27725       {
27726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27727       };
27728     } catch (std::exception& e) {
27729       {
27730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27731       };
27732     } catch (Dali::DaliException e) {
27733       {
27734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27735       };
27736     } catch (...) {
27737       {
27738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27739       };
27740     }
27741   }
27742
27743   jresult = (void *)result;
27744   return jresult;
27745 }
27746
27747
27748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27749   void * jresult ;
27750   Dali::BaseHandle arg1 ;
27751   Dali::BaseHandle *argp1 ;
27752   Dali::RenderTaskList result;
27753
27754   argp1 = (Dali::BaseHandle *)jarg1;
27755   if (!argp1) {
27756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27757     return 0;
27758   }
27759   arg1 = *argp1;
27760   {
27761     try {
27762       result = Dali::RenderTaskList::DownCast(arg1);
27763     } catch (std::out_of_range& e) {
27764       {
27765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27766       };
27767     } catch (std::exception& e) {
27768       {
27769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27770       };
27771     } catch (Dali::DaliException e) {
27772       {
27773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27774       };
27775     } catch (...) {
27776       {
27777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27778       };
27779     }
27780   }
27781
27782   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27783   return jresult;
27784 }
27785
27786
27787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27788   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27789
27790   arg1 = (Dali::RenderTaskList *)jarg1;
27791   {
27792     try {
27793       delete arg1;
27794     } catch (std::out_of_range& e) {
27795       {
27796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27797       };
27798     } catch (std::exception& e) {
27799       {
27800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27801       };
27802     } catch (Dali::DaliException e) {
27803       {
27804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27805       };
27806     } catch (...) {
27807       {
27808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27809       };
27810     }
27811   }
27812
27813 }
27814
27815
27816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27817   void * jresult ;
27818   Dali::RenderTaskList *arg1 = 0 ;
27819   Dali::RenderTaskList *result = 0 ;
27820
27821   arg1 = (Dali::RenderTaskList *)jarg1;
27822   if (!arg1) {
27823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27824     return 0;
27825   }
27826   {
27827     try {
27828       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27829     } catch (std::out_of_range& e) {
27830       {
27831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27832       };
27833     } catch (std::exception& e) {
27834       {
27835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27836       };
27837     } catch (Dali::DaliException e) {
27838       {
27839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27840       };
27841     } catch (...) {
27842       {
27843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27844       };
27845     }
27846   }
27847
27848   jresult = (void *)result;
27849   return jresult;
27850 }
27851
27852
27853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27854   void * jresult ;
27855   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27856   Dali::RenderTaskList *arg2 = 0 ;
27857   Dali::RenderTaskList *result = 0 ;
27858
27859   arg1 = (Dali::RenderTaskList *)jarg1;
27860   arg2 = (Dali::RenderTaskList *)jarg2;
27861   if (!arg2) {
27862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27863     return 0;
27864   }
27865   {
27866     try {
27867       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27868     } catch (std::out_of_range& e) {
27869       {
27870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27871       };
27872     } catch (std::exception& e) {
27873       {
27874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27875       };
27876     } catch (Dali::DaliException e) {
27877       {
27878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27879       };
27880     } catch (...) {
27881       {
27882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27883       };
27884     }
27885   }
27886
27887   jresult = (void *)result;
27888   return jresult;
27889 }
27890
27891
27892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27893   void * jresult ;
27894   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27895   Dali::RenderTask result;
27896
27897   arg1 = (Dali::RenderTaskList *)jarg1;
27898   {
27899     try {
27900       result = (arg1)->CreateTask();
27901     } catch (std::out_of_range& e) {
27902       {
27903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27904       };
27905     } catch (std::exception& e) {
27906       {
27907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27908       };
27909     } catch (Dali::DaliException e) {
27910       {
27911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27912       };
27913     } catch (...) {
27914       {
27915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27916       };
27917     }
27918   }
27919
27920   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27921   return jresult;
27922 }
27923
27924
27925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27926   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27927   Dali::RenderTask arg2 ;
27928   Dali::RenderTask *argp2 ;
27929
27930   arg1 = (Dali::RenderTaskList *)jarg1;
27931   argp2 = (Dali::RenderTask *)jarg2;
27932   if (!argp2) {
27933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27934     return ;
27935   }
27936   arg2 = *argp2;
27937   {
27938     try {
27939       (arg1)->RemoveTask(arg2);
27940     } catch (std::out_of_range& e) {
27941       {
27942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27943       };
27944     } catch (std::exception& e) {
27945       {
27946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27947       };
27948     } catch (Dali::DaliException e) {
27949       {
27950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27951       };
27952     } catch (...) {
27953       {
27954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27955       };
27956     }
27957   }
27958
27959 }
27960
27961
27962 //// ===============================================end part 1 =================
27963
27964 //// ========================= part 2 ===============================
27965
27966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27967   unsigned int jresult ;
27968   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27969   unsigned int result;
27970
27971   arg1 = (Dali::RenderTaskList *)jarg1;
27972   {
27973     try {
27974       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27975     } catch (std::out_of_range& e) {
27976       {
27977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27978       };
27979     } catch (std::exception& e) {
27980       {
27981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27982       };
27983     } catch (Dali::DaliException e) {
27984       {
27985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27986       };
27987     } catch (...) {
27988       {
27989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27990       };
27991     }
27992   }
27993
27994   jresult = result;
27995   return jresult;
27996 }
27997
27998
27999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28000   void * jresult ;
28001   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28002   unsigned int arg2 ;
28003   Dali::RenderTask result;
28004
28005   arg1 = (Dali::RenderTaskList *)jarg1;
28006   arg2 = (unsigned int)jarg2;
28007   {
28008     try {
28009       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28010     } catch (std::out_of_range& e) {
28011       {
28012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28013       };
28014     } catch (std::exception& e) {
28015       {
28016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28017       };
28018     } catch (Dali::DaliException e) {
28019       {
28020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28021       };
28022     } catch (...) {
28023       {
28024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28025       };
28026     }
28027   }
28028
28029   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28030   return jresult;
28031 }
28032
28033
28034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28035   int jresult ;
28036   int result;
28037
28038   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28039   jresult = (int)result;
28040   return jresult;
28041 }
28042
28043
28044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28045   int jresult ;
28046   int result;
28047
28048   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28049   jresult = (int)result;
28050   return jresult;
28051 }
28052
28053
28054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28055   int jresult ;
28056   int result;
28057
28058   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28059   jresult = (int)result;
28060   return jresult;
28061 }
28062
28063
28064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28065   int jresult ;
28066   int result;
28067
28068   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28069   jresult = (int)result;
28070   return jresult;
28071 }
28072
28073
28074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28075   void * jresult ;
28076   Dali::RenderTask::Property *result = 0 ;
28077
28078   {
28079     try {
28080       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28081     } catch (std::out_of_range& e) {
28082       {
28083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28084       };
28085     } catch (std::exception& e) {
28086       {
28087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28088       };
28089     } catch (Dali::DaliException e) {
28090       {
28091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28092       };
28093     } catch (...) {
28094       {
28095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28096       };
28097     }
28098   }
28099
28100   jresult = (void *)result;
28101   return jresult;
28102 }
28103
28104
28105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28106   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28107
28108   arg1 = (Dali::RenderTask::Property *)jarg1;
28109   {
28110     try {
28111       delete arg1;
28112     } catch (std::out_of_range& e) {
28113       {
28114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28115       };
28116     } catch (std::exception& e) {
28117       {
28118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28119       };
28120     } catch (Dali::DaliException e) {
28121       {
28122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28123       };
28124     } catch (...) {
28125       {
28126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28127       };
28128     }
28129   }
28130
28131 }
28132
28133
28134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28135   void * jresult ;
28136   bool (*result)(Dali::Vector2 &) = 0 ;
28137
28138   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28139   jresult = (void *)result;
28140   return jresult;
28141 }
28142
28143
28144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28145   void * jresult ;
28146   bool (*result)(Dali::Vector2 &) = 0 ;
28147
28148   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28149   jresult = (void *)result;
28150   return jresult;
28151 }
28152
28153
28154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28155   unsigned int jresult ;
28156   bool result;
28157
28158   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28159   jresult = result;
28160   return jresult;
28161 }
28162
28163
28164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28165   unsigned int jresult ;
28166   bool result;
28167
28168   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28169   jresult = result;
28170   return jresult;
28171 }
28172
28173
28174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28175   void * jresult ;
28176   Dali::Vector4 *result = 0 ;
28177
28178   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28179   jresult = (void *)result;
28180   return jresult;
28181 }
28182
28183
28184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28185   unsigned int jresult ;
28186   bool result;
28187
28188   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28189   jresult = result;
28190   return jresult;
28191 }
28192
28193
28194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28195   unsigned int jresult ;
28196   bool result;
28197
28198   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28199   jresult = result;
28200   return jresult;
28201 }
28202
28203
28204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28205   unsigned int jresult ;
28206   unsigned int result;
28207
28208   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28209   jresult = result;
28210   return jresult;
28211 }
28212
28213
28214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28215   void * jresult ;
28216   Dali::RenderTask *result = 0 ;
28217
28218   {
28219     try {
28220       result = (Dali::RenderTask *)new Dali::RenderTask();
28221     } catch (std::out_of_range& e) {
28222       {
28223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28224       };
28225     } catch (std::exception& e) {
28226       {
28227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28228       };
28229     } catch (Dali::DaliException e) {
28230       {
28231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28232       };
28233     } catch (...) {
28234       {
28235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28236       };
28237     }
28238   }
28239
28240   jresult = (void *)result;
28241   return jresult;
28242 }
28243
28244
28245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28246   void * jresult ;
28247   Dali::BaseHandle arg1 ;
28248   Dali::BaseHandle *argp1 ;
28249   Dali::RenderTask result;
28250
28251   argp1 = (Dali::BaseHandle *)jarg1;
28252   if (!argp1) {
28253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28254     return 0;
28255   }
28256   arg1 = *argp1;
28257   {
28258     try {
28259       result = Dali::RenderTask::DownCast(arg1);
28260     } catch (std::out_of_range& e) {
28261       {
28262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28263       };
28264     } catch (std::exception& e) {
28265       {
28266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28267       };
28268     } catch (Dali::DaliException e) {
28269       {
28270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28271       };
28272     } catch (...) {
28273       {
28274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28275       };
28276     }
28277   }
28278
28279   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28280   return jresult;
28281 }
28282
28283
28284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28285   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28286
28287   arg1 = (Dali::RenderTask *)jarg1;
28288   {
28289     try {
28290       delete arg1;
28291     } catch (std::out_of_range& e) {
28292       {
28293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28294       };
28295     } catch (std::exception& e) {
28296       {
28297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28298       };
28299     } catch (Dali::DaliException e) {
28300       {
28301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28302       };
28303     } catch (...) {
28304       {
28305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28306       };
28307     }
28308   }
28309
28310 }
28311
28312
28313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28314   void * jresult ;
28315   Dali::RenderTask *arg1 = 0 ;
28316   Dali::RenderTask *result = 0 ;
28317
28318   arg1 = (Dali::RenderTask *)jarg1;
28319   if (!arg1) {
28320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28321     return 0;
28322   }
28323   {
28324     try {
28325       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28326     } catch (std::out_of_range& e) {
28327       {
28328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28329       };
28330     } catch (std::exception& e) {
28331       {
28332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28333       };
28334     } catch (Dali::DaliException e) {
28335       {
28336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28337       };
28338     } catch (...) {
28339       {
28340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28341       };
28342     }
28343   }
28344
28345   jresult = (void *)result;
28346   return jresult;
28347 }
28348
28349
28350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28351   void * jresult ;
28352   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28353   Dali::RenderTask *arg2 = 0 ;
28354   Dali::RenderTask *result = 0 ;
28355
28356   arg1 = (Dali::RenderTask *)jarg1;
28357   arg2 = (Dali::RenderTask *)jarg2;
28358   if (!arg2) {
28359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28360     return 0;
28361   }
28362   {
28363     try {
28364       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28365     } catch (std::out_of_range& e) {
28366       {
28367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28368       };
28369     } catch (std::exception& e) {
28370       {
28371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28372       };
28373     } catch (Dali::DaliException e) {
28374       {
28375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28376       };
28377     } catch (...) {
28378       {
28379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28380       };
28381     }
28382   }
28383
28384   jresult = (void *)result;
28385   return jresult;
28386 }
28387
28388
28389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28390   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28391   Dali::Actor arg2 ;
28392   Dali::Actor *argp2 ;
28393
28394   arg1 = (Dali::RenderTask *)jarg1;
28395   argp2 = (Dali::Actor *)jarg2;
28396   if (!argp2) {
28397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28398     return ;
28399   }
28400   arg2 = *argp2;
28401   {
28402     try {
28403       (arg1)->SetSourceActor(arg2);
28404     } catch (std::out_of_range& e) {
28405       {
28406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28407       };
28408     } catch (std::exception& e) {
28409       {
28410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28411       };
28412     } catch (Dali::DaliException e) {
28413       {
28414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28415       };
28416     } catch (...) {
28417       {
28418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28419       };
28420     }
28421   }
28422
28423 }
28424
28425
28426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28427   void * jresult ;
28428   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28429   Dali::Actor result;
28430
28431   arg1 = (Dali::RenderTask *)jarg1;
28432   {
28433     try {
28434       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28435     } catch (std::out_of_range& e) {
28436       {
28437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28438       };
28439     } catch (std::exception& e) {
28440       {
28441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28442       };
28443     } catch (Dali::DaliException e) {
28444       {
28445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28446       };
28447     } catch (...) {
28448       {
28449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28450       };
28451     }
28452   }
28453
28454   jresult = new Dali::Actor((const Dali::Actor &)result);
28455   return jresult;
28456 }
28457
28458
28459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28460   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28461   bool arg2 ;
28462
28463   arg1 = (Dali::RenderTask *)jarg1;
28464   arg2 = jarg2 ? true : false;
28465   {
28466     try {
28467       (arg1)->SetExclusive(arg2);
28468     } catch (std::out_of_range& e) {
28469       {
28470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28471       };
28472     } catch (std::exception& e) {
28473       {
28474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28475       };
28476     } catch (Dali::DaliException e) {
28477       {
28478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28479       };
28480     } catch (...) {
28481       {
28482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28483       };
28484     }
28485   }
28486
28487 }
28488
28489
28490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28491   unsigned int jresult ;
28492   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28493   bool result;
28494
28495   arg1 = (Dali::RenderTask *)jarg1;
28496   {
28497     try {
28498       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28499     } catch (std::out_of_range& e) {
28500       {
28501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28502       };
28503     } catch (std::exception& e) {
28504       {
28505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28506       };
28507     } catch (Dali::DaliException e) {
28508       {
28509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28510       };
28511     } catch (...) {
28512       {
28513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28514       };
28515     }
28516   }
28517
28518   jresult = result;
28519   return jresult;
28520 }
28521
28522
28523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28524   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28525   bool arg2 ;
28526
28527   arg1 = (Dali::RenderTask *)jarg1;
28528   arg2 = jarg2 ? true : false;
28529   {
28530     try {
28531       (arg1)->SetInputEnabled(arg2);
28532     } catch (std::out_of_range& e) {
28533       {
28534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28535       };
28536     } catch (std::exception& e) {
28537       {
28538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28539       };
28540     } catch (Dali::DaliException e) {
28541       {
28542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28543       };
28544     } catch (...) {
28545       {
28546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28547       };
28548     }
28549   }
28550
28551 }
28552
28553
28554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28555   unsigned int jresult ;
28556   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28557   bool result;
28558
28559   arg1 = (Dali::RenderTask *)jarg1;
28560   {
28561     try {
28562       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28563     } catch (std::out_of_range& e) {
28564       {
28565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28566       };
28567     } catch (std::exception& e) {
28568       {
28569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28570       };
28571     } catch (Dali::DaliException e) {
28572       {
28573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28574       };
28575     } catch (...) {
28576       {
28577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28578       };
28579     }
28580   }
28581
28582   jresult = result;
28583   return jresult;
28584 }
28585
28586
28587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28588   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28589   Dali::CameraActor arg2 ;
28590   Dali::CameraActor *argp2 ;
28591
28592   arg1 = (Dali::RenderTask *)jarg1;
28593   argp2 = (Dali::CameraActor *)jarg2;
28594   if (!argp2) {
28595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28596     return ;
28597   }
28598   arg2 = *argp2;
28599   {
28600     try {
28601       (arg1)->SetCameraActor(arg2);
28602     } catch (std::out_of_range& e) {
28603       {
28604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28605       };
28606     } catch (std::exception& e) {
28607       {
28608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28609       };
28610     } catch (Dali::DaliException e) {
28611       {
28612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28613       };
28614     } catch (...) {
28615       {
28616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28617       };
28618     }
28619   }
28620
28621 }
28622
28623
28624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28625   void * jresult ;
28626   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28627   Dali::CameraActor result;
28628
28629   arg1 = (Dali::RenderTask *)jarg1;
28630   {
28631     try {
28632       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28633     } catch (std::out_of_range& e) {
28634       {
28635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28636       };
28637     } catch (std::exception& e) {
28638       {
28639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28640       };
28641     } catch (Dali::DaliException e) {
28642       {
28643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28644       };
28645     } catch (...) {
28646       {
28647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28648       };
28649     }
28650   }
28651
28652   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28653   return jresult;
28654 }
28655
28656
28657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28658   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28659   Dali::FrameBufferImage arg2 ;
28660   Dali::FrameBufferImage *argp2 ;
28661
28662   arg1 = (Dali::RenderTask *)jarg1;
28663   argp2 = (Dali::FrameBufferImage *)jarg2;
28664   if (!argp2) {
28665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28666     return ;
28667   }
28668   arg2 = *argp2;
28669   {
28670     try {
28671       (arg1)->SetTargetFrameBuffer(arg2);
28672     } catch (std::out_of_range& e) {
28673       {
28674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28675       };
28676     } catch (std::exception& e) {
28677       {
28678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28679       };
28680     } catch (Dali::DaliException e) {
28681       {
28682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28683       };
28684     } catch (...) {
28685       {
28686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28687       };
28688     }
28689   }
28690
28691 }
28692
28693
28694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28695   void * jresult ;
28696   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28697   Dali::FrameBufferImage result;
28698
28699   arg1 = (Dali::RenderTask *)jarg1;
28700   {
28701     try {
28702       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28703     } catch (std::out_of_range& e) {
28704       {
28705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28706       };
28707     } catch (std::exception& e) {
28708       {
28709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28710       };
28711     } catch (Dali::DaliException e) {
28712       {
28713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28714       };
28715     } catch (...) {
28716       {
28717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28718       };
28719     }
28720   }
28721
28722   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28723   return jresult;
28724 }
28725
28726
28727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28728   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28729   Dali::FrameBuffer arg2 ;
28730   Dali::FrameBuffer *argp2 ;
28731
28732   arg1 = (Dali::RenderTask *)jarg1;
28733   argp2 = (Dali::FrameBuffer *)jarg2;
28734   if (!argp2) {
28735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28736     return ;
28737   }
28738   arg2 = *argp2;
28739   {
28740     try {
28741       (arg1)->SetFrameBuffer(arg2);
28742     } catch (std::out_of_range& e) {
28743       {
28744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28745       };
28746     } catch (std::exception& e) {
28747       {
28748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28749       };
28750     } catch (Dali::DaliException e) {
28751       {
28752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28753       };
28754     } catch (...) {
28755       {
28756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28757       };
28758     }
28759   }
28760
28761 }
28762
28763
28764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28765   void * jresult ;
28766   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28767   Dali::FrameBuffer result;
28768
28769   arg1 = (Dali::RenderTask *)jarg1;
28770   {
28771     try {
28772       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28773     } catch (std::out_of_range& e) {
28774       {
28775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28776       };
28777     } catch (std::exception& e) {
28778       {
28779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28780       };
28781     } catch (Dali::DaliException e) {
28782       {
28783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28784       };
28785     } catch (...) {
28786       {
28787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28788       };
28789     }
28790   }
28791
28792   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28793   return jresult;
28794 }
28795
28796
28797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28798   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28799   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28800
28801   arg1 = (Dali::RenderTask *)jarg1;
28802   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28803   {
28804     try {
28805       (arg1)->SetScreenToFrameBufferFunction(arg2);
28806     } catch (std::out_of_range& e) {
28807       {
28808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28809       };
28810     } catch (std::exception& e) {
28811       {
28812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28813       };
28814     } catch (Dali::DaliException e) {
28815       {
28816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28817       };
28818     } catch (...) {
28819       {
28820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28821       };
28822     }
28823   }
28824
28825 }
28826
28827
28828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28829   void * jresult ;
28830   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28831   Dali::RenderTask::ScreenToFrameBufferFunction result;
28832
28833   arg1 = (Dali::RenderTask *)jarg1;
28834   {
28835     try {
28836       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28837     } catch (std::out_of_range& e) {
28838       {
28839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28840       };
28841     } catch (std::exception& e) {
28842       {
28843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28844       };
28845     } catch (Dali::DaliException e) {
28846       {
28847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28848       };
28849     } catch (...) {
28850       {
28851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28852       };
28853     }
28854   }
28855
28856   jresult = (void *)result;
28857   return jresult;
28858 }
28859
28860
28861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28862   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28863   Dali::Actor arg2 ;
28864   Dali::Actor *argp2 ;
28865
28866   arg1 = (Dali::RenderTask *)jarg1;
28867   argp2 = (Dali::Actor *)jarg2;
28868   if (!argp2) {
28869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28870     return ;
28871   }
28872   arg2 = *argp2;
28873   {
28874     try {
28875       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28876     } catch (std::out_of_range& e) {
28877       {
28878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28879       };
28880     } catch (std::exception& e) {
28881       {
28882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28883       };
28884     } catch (Dali::DaliException e) {
28885       {
28886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28887       };
28888     } catch (...) {
28889       {
28890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28891       };
28892     }
28893   }
28894
28895 }
28896
28897
28898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28899   void * jresult ;
28900   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28901   Dali::Actor result;
28902
28903   arg1 = (Dali::RenderTask *)jarg1;
28904   {
28905     try {
28906       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28907     } catch (std::out_of_range& e) {
28908       {
28909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28910       };
28911     } catch (std::exception& e) {
28912       {
28913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28914       };
28915     } catch (Dali::DaliException e) {
28916       {
28917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28918       };
28919     } catch (...) {
28920       {
28921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28922       };
28923     }
28924   }
28925
28926   jresult = new Dali::Actor((const Dali::Actor &)result);
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28932   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28933   Dali::Vector2 arg2 ;
28934   Dali::Vector2 *argp2 ;
28935
28936   arg1 = (Dali::RenderTask *)jarg1;
28937   argp2 = (Dali::Vector2 *)jarg2;
28938   if (!argp2) {
28939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28940     return ;
28941   }
28942   arg2 = *argp2;
28943   {
28944     try {
28945       (arg1)->SetViewportPosition(arg2);
28946     } catch (std::out_of_range& e) {
28947       {
28948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28949       };
28950     } catch (std::exception& e) {
28951       {
28952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28953       };
28954     } catch (Dali::DaliException e) {
28955       {
28956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28957       };
28958     } catch (...) {
28959       {
28960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28961       };
28962     }
28963   }
28964
28965 }
28966
28967
28968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28969   void * jresult ;
28970   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28971   Dali::Vector2 result;
28972
28973   arg1 = (Dali::RenderTask *)jarg1;
28974   {
28975     try {
28976       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28977     } catch (std::out_of_range& e) {
28978       {
28979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28980       };
28981     } catch (std::exception& e) {
28982       {
28983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28984       };
28985     } catch (Dali::DaliException e) {
28986       {
28987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28988       };
28989     } catch (...) {
28990       {
28991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28992       };
28993     }
28994   }
28995
28996   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28997   return jresult;
28998 }
28999
29000
29001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29002   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29003   Dali::Vector2 arg2 ;
29004   Dali::Vector2 *argp2 ;
29005
29006   arg1 = (Dali::RenderTask *)jarg1;
29007   argp2 = (Dali::Vector2 *)jarg2;
29008   if (!argp2) {
29009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29010     return ;
29011   }
29012   arg2 = *argp2;
29013   {
29014     try {
29015       (arg1)->SetViewportSize(arg2);
29016     } catch (std::out_of_range& e) {
29017       {
29018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29019       };
29020     } catch (std::exception& e) {
29021       {
29022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29023       };
29024     } catch (Dali::DaliException e) {
29025       {
29026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29027       };
29028     } catch (...) {
29029       {
29030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29031       };
29032     }
29033   }
29034
29035 }
29036
29037
29038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29039   void * jresult ;
29040   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29041   Dali::Vector2 result;
29042
29043   arg1 = (Dali::RenderTask *)jarg1;
29044   {
29045     try {
29046       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29047     } catch (std::out_of_range& e) {
29048       {
29049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29050       };
29051     } catch (std::exception& e) {
29052       {
29053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29054       };
29055     } catch (Dali::DaliException e) {
29056       {
29057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29058       };
29059     } catch (...) {
29060       {
29061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29062       };
29063     }
29064   }
29065
29066   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29067   return jresult;
29068 }
29069
29070
29071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29072   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29073   Dali::Viewport arg2 ;
29074   Dali::Viewport *argp2 ;
29075
29076   arg1 = (Dali::RenderTask *)jarg1;
29077   argp2 = (Dali::Viewport *)jarg2;
29078   if (!argp2) {
29079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29080     return ;
29081   }
29082   arg2 = *argp2;
29083   {
29084     try {
29085       (arg1)->SetViewport(arg2);
29086     } catch (std::out_of_range& e) {
29087       {
29088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29089       };
29090     } catch (std::exception& e) {
29091       {
29092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29093       };
29094     } catch (Dali::DaliException e) {
29095       {
29096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29097       };
29098     } catch (...) {
29099       {
29100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29101       };
29102     }
29103   }
29104
29105 }
29106
29107
29108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29109   void * jresult ;
29110   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29111   Dali::Viewport result;
29112
29113   arg1 = (Dali::RenderTask *)jarg1;
29114   {
29115     try {
29116       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29117     } catch (std::out_of_range& e) {
29118       {
29119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29120       };
29121     } catch (std::exception& e) {
29122       {
29123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29124       };
29125     } catch (Dali::DaliException e) {
29126       {
29127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29128       };
29129     } catch (...) {
29130       {
29131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29132       };
29133     }
29134   }
29135
29136   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29137   return jresult;
29138 }
29139
29140
29141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29142   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29143   Dali::Vector4 *arg2 = 0 ;
29144
29145   arg1 = (Dali::RenderTask *)jarg1;
29146   arg2 = (Dali::Vector4 *)jarg2;
29147   if (!arg2) {
29148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29149     return ;
29150   }
29151   {
29152     try {
29153       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29154     } catch (std::out_of_range& e) {
29155       {
29156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29157       };
29158     } catch (std::exception& e) {
29159       {
29160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29161       };
29162     } catch (Dali::DaliException e) {
29163       {
29164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29165       };
29166     } catch (...) {
29167       {
29168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29169       };
29170     }
29171   }
29172
29173 }
29174
29175
29176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29177   void * jresult ;
29178   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29179   Dali::Vector4 result;
29180
29181   arg1 = (Dali::RenderTask *)jarg1;
29182   {
29183     try {
29184       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29185     } catch (std::out_of_range& e) {
29186       {
29187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29188       };
29189     } catch (std::exception& e) {
29190       {
29191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29192       };
29193     } catch (Dali::DaliException e) {
29194       {
29195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29196       };
29197     } catch (...) {
29198       {
29199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29200       };
29201     }
29202   }
29203
29204   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29205   return jresult;
29206 }
29207
29208
29209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29210   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29211   bool arg2 ;
29212
29213   arg1 = (Dali::RenderTask *)jarg1;
29214   arg2 = jarg2 ? true : false;
29215   {
29216     try {
29217       (arg1)->SetClearEnabled(arg2);
29218     } catch (std::out_of_range& e) {
29219       {
29220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29221       };
29222     } catch (std::exception& e) {
29223       {
29224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29225       };
29226     } catch (Dali::DaliException e) {
29227       {
29228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29229       };
29230     } catch (...) {
29231       {
29232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29233       };
29234     }
29235   }
29236
29237 }
29238
29239
29240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29241   unsigned int jresult ;
29242   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29243   bool result;
29244
29245   arg1 = (Dali::RenderTask *)jarg1;
29246   {
29247     try {
29248       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29249     } catch (std::out_of_range& e) {
29250       {
29251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29252       };
29253     } catch (std::exception& e) {
29254       {
29255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29256       };
29257     } catch (Dali::DaliException e) {
29258       {
29259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29260       };
29261     } catch (...) {
29262       {
29263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29264       };
29265     }
29266   }
29267
29268   jresult = result;
29269   return jresult;
29270 }
29271
29272
29273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29274   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29275   bool arg2 ;
29276
29277   arg1 = (Dali::RenderTask *)jarg1;
29278   arg2 = jarg2 ? true : false;
29279   {
29280     try {
29281       (arg1)->SetCullMode(arg2);
29282     } catch (std::out_of_range& e) {
29283       {
29284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29285       };
29286     } catch (std::exception& e) {
29287       {
29288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29289       };
29290     } catch (Dali::DaliException e) {
29291       {
29292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29293       };
29294     } catch (...) {
29295       {
29296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29297       };
29298     }
29299   }
29300
29301 }
29302
29303
29304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29305   unsigned int jresult ;
29306   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29307   bool result;
29308
29309   arg1 = (Dali::RenderTask *)jarg1;
29310   {
29311     try {
29312       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29313     } catch (std::out_of_range& e) {
29314       {
29315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29316       };
29317     } catch (std::exception& e) {
29318       {
29319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29320       };
29321     } catch (Dali::DaliException e) {
29322       {
29323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29324       };
29325     } catch (...) {
29326       {
29327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29328       };
29329     }
29330   }
29331
29332   jresult = result;
29333   return jresult;
29334 }
29335
29336
29337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29338   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29339   unsigned int arg2 ;
29340
29341   arg1 = (Dali::RenderTask *)jarg1;
29342   arg2 = (unsigned int)jarg2;
29343   {
29344     try {
29345       (arg1)->SetRefreshRate(arg2);
29346     } catch (std::out_of_range& e) {
29347       {
29348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29349       };
29350     } catch (std::exception& e) {
29351       {
29352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29353       };
29354     } catch (Dali::DaliException e) {
29355       {
29356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29357       };
29358     } catch (...) {
29359       {
29360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29361       };
29362     }
29363   }
29364
29365 }
29366
29367
29368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29369   unsigned int jresult ;
29370   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29371   unsigned int result;
29372
29373   arg1 = (Dali::RenderTask *)jarg1;
29374   {
29375     try {
29376       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29377     } catch (std::out_of_range& e) {
29378       {
29379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29380       };
29381     } catch (std::exception& e) {
29382       {
29383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29384       };
29385     } catch (Dali::DaliException e) {
29386       {
29387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29388       };
29389     } catch (...) {
29390       {
29391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29392       };
29393     }
29394   }
29395
29396   jresult = result;
29397   return jresult;
29398 }
29399
29400
29401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29402   unsigned int jresult ;
29403   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29404   Dali::Vector3 *arg2 = 0 ;
29405   float *arg3 = 0 ;
29406   float *arg4 = 0 ;
29407   bool result;
29408
29409   arg1 = (Dali::RenderTask *)jarg1;
29410   arg2 = (Dali::Vector3 *)jarg2;
29411   if (!arg2) {
29412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29413     return 0;
29414   }
29415   arg3 = (float *)jarg3;
29416   arg4 = (float *)jarg4;
29417   {
29418     try {
29419       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29420     } catch (std::out_of_range& e) {
29421       {
29422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29423       };
29424     } catch (std::exception& e) {
29425       {
29426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29427       };
29428     } catch (Dali::DaliException e) {
29429       {
29430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29431       };
29432     } catch (...) {
29433       {
29434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29435       };
29436     }
29437   }
29438
29439   jresult = result;
29440   return jresult;
29441 }
29442
29443
29444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29445   unsigned int jresult ;
29446   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29447   Dali::Actor arg2 ;
29448   float arg3 ;
29449   float arg4 ;
29450   float *arg5 = 0 ;
29451   float *arg6 = 0 ;
29452   Dali::Actor *argp2 ;
29453   bool result;
29454
29455   arg1 = (Dali::RenderTask *)jarg1;
29456   argp2 = (Dali::Actor *)jarg2;
29457   if (!argp2) {
29458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29459     return 0;
29460   }
29461   arg2 = *argp2;
29462   arg3 = (float)jarg3;
29463   arg4 = (float)jarg4;
29464   arg5 = (float *)jarg5;
29465   arg6 = (float *)jarg6;
29466   {
29467     try {
29468       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29469     } catch (std::out_of_range& e) {
29470       {
29471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29472       };
29473     } catch (std::exception& e) {
29474       {
29475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29476       };
29477     } catch (Dali::DaliException e) {
29478       {
29479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29480       };
29481     } catch (...) {
29482       {
29483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29484       };
29485     }
29486   }
29487
29488   jresult = result;
29489   return jresult;
29490 }
29491
29492
29493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29494   void * jresult ;
29495   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29496   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29497
29498   arg1 = (Dali::RenderTask *)jarg1;
29499   {
29500     try {
29501       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29502     } catch (std::out_of_range& e) {
29503       {
29504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29505       };
29506     } catch (std::exception& e) {
29507       {
29508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29509       };
29510     } catch (Dali::DaliException e) {
29511       {
29512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29513       };
29514     } catch (...) {
29515       {
29516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29517       };
29518     }
29519   }
29520
29521   jresult = (void *)result;
29522   return jresult;
29523 }
29524
29525
29526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29527   void * jresult ;
29528   int arg1 ;
29529   Dali::TouchPoint::State arg2 ;
29530   float arg3 ;
29531   float arg4 ;
29532   Dali::TouchPoint *result = 0 ;
29533
29534   arg1 = (int)jarg1;
29535   arg2 = (Dali::TouchPoint::State)jarg2;
29536   arg3 = (float)jarg3;
29537   arg4 = (float)jarg4;
29538   {
29539     try {
29540       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29541     } catch (std::out_of_range& e) {
29542       {
29543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29544       };
29545     } catch (std::exception& e) {
29546       {
29547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29548       };
29549     } catch (Dali::DaliException e) {
29550       {
29551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29552       };
29553     } catch (...) {
29554       {
29555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29556       };
29557     }
29558   }
29559
29560   jresult = (void *)result;
29561   return jresult;
29562 }
29563
29564
29565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29566   void * jresult ;
29567   int arg1 ;
29568   Dali::TouchPoint::State arg2 ;
29569   float arg3 ;
29570   float arg4 ;
29571   float arg5 ;
29572   float arg6 ;
29573   Dali::TouchPoint *result = 0 ;
29574
29575   arg1 = (int)jarg1;
29576   arg2 = (Dali::TouchPoint::State)jarg2;
29577   arg3 = (float)jarg3;
29578   arg4 = (float)jarg4;
29579   arg5 = (float)jarg5;
29580   arg6 = (float)jarg6;
29581   {
29582     try {
29583       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29584     } catch (std::out_of_range& e) {
29585       {
29586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29587       };
29588     } catch (std::exception& e) {
29589       {
29590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29591       };
29592     } catch (Dali::DaliException e) {
29593       {
29594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29595       };
29596     } catch (...) {
29597       {
29598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29599       };
29600     }
29601   }
29602
29603   jresult = (void *)result;
29604   return jresult;
29605 }
29606
29607
29608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29609   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29610
29611   arg1 = (Dali::TouchPoint *)jarg1;
29612   {
29613     try {
29614       delete arg1;
29615     } catch (std::out_of_range& e) {
29616       {
29617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29618       };
29619     } catch (std::exception& e) {
29620       {
29621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29622       };
29623     } catch (Dali::DaliException e) {
29624       {
29625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29626       };
29627     } catch (...) {
29628       {
29629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29630       };
29631     }
29632   }
29633
29634 }
29635
29636
29637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29638   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29639   int arg2 ;
29640
29641   arg1 = (Dali::TouchPoint *)jarg1;
29642   arg2 = (int)jarg2;
29643   if (arg1) (arg1)->deviceId = arg2;
29644 }
29645
29646
29647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29648   int jresult ;
29649   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29650   int result;
29651
29652   arg1 = (Dali::TouchPoint *)jarg1;
29653   result = (int) ((arg1)->deviceId);
29654   jresult = result;
29655   return jresult;
29656 }
29657
29658
29659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29660   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29661   Dali::TouchPoint::State arg2 ;
29662
29663   arg1 = (Dali::TouchPoint *)jarg1;
29664   arg2 = (Dali::TouchPoint::State)jarg2;
29665   if (arg1) (arg1)->state = arg2;
29666 }
29667
29668
29669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29670   int jresult ;
29671   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29672   Dali::TouchPoint::State result;
29673
29674   arg1 = (Dali::TouchPoint *)jarg1;
29675   result = (Dali::TouchPoint::State) ((arg1)->state);
29676   jresult = (int)result;
29677   return jresult;
29678 }
29679
29680
29681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29682   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29683   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29684
29685   arg1 = (Dali::TouchPoint *)jarg1;
29686   arg2 = (Dali::Actor *)jarg2;
29687   if (arg1) (arg1)->hitActor = *arg2;
29688 }
29689
29690
29691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29692   void * jresult ;
29693   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29694   Dali::Actor *result = 0 ;
29695
29696   arg1 = (Dali::TouchPoint *)jarg1;
29697   result = (Dali::Actor *)& ((arg1)->hitActor);
29698   jresult = (void *)result;
29699   return jresult;
29700 }
29701
29702
29703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29704   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29705   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29706
29707   arg1 = (Dali::TouchPoint *)jarg1;
29708   arg2 = (Dali::Vector2 *)jarg2;
29709   if (arg1) (arg1)->local = *arg2;
29710 }
29711
29712
29713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29714   void * jresult ;
29715   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29716   Dali::Vector2 *result = 0 ;
29717
29718   arg1 = (Dali::TouchPoint *)jarg1;
29719   result = (Dali::Vector2 *)& ((arg1)->local);
29720   jresult = (void *)result;
29721   return jresult;
29722 }
29723
29724
29725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29726   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29727   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29728
29729   arg1 = (Dali::TouchPoint *)jarg1;
29730   arg2 = (Dali::Vector2 *)jarg2;
29731   if (arg1) (arg1)->screen = *arg2;
29732 }
29733
29734
29735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29736   void * jresult ;
29737   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29738   Dali::Vector2 *result = 0 ;
29739
29740   arg1 = (Dali::TouchPoint *)jarg1;
29741   result = (Dali::Vector2 *)& ((arg1)->screen);
29742   jresult = (void *)result;
29743   return jresult;
29744 }
29745
29746
29747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29748   void * jresult ;
29749   Dali::TouchData *result = 0 ;
29750
29751   {
29752     try {
29753       result = (Dali::TouchData *)new Dali::TouchData();
29754     } catch (std::out_of_range& e) {
29755       {
29756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29757       };
29758     } catch (std::exception& e) {
29759       {
29760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29761       };
29762     } catch (Dali::DaliException e) {
29763       {
29764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29765       };
29766     } catch (...) {
29767       {
29768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29769       };
29770     }
29771   }
29772
29773   jresult = (void *)result;
29774   return jresult;
29775 }
29776
29777
29778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29779   void * jresult ;
29780   Dali::TouchData *arg1 = 0 ;
29781   Dali::TouchData *result = 0 ;
29782
29783   arg1 = (Dali::TouchData *)jarg1;
29784   if (!arg1) {
29785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29786     return 0;
29787   }
29788   {
29789     try {
29790       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29791     } catch (std::out_of_range& e) {
29792       {
29793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29794       };
29795     } catch (std::exception& e) {
29796       {
29797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29798       };
29799     } catch (Dali::DaliException e) {
29800       {
29801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29802       };
29803     } catch (...) {
29804       {
29805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29806       };
29807     }
29808   }
29809
29810   jresult = (void *)result;
29811   return jresult;
29812 }
29813
29814
29815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29816   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29817
29818   arg1 = (Dali::TouchData *)jarg1;
29819   {
29820     try {
29821       delete arg1;
29822     } catch (std::out_of_range& e) {
29823       {
29824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29825       };
29826     } catch (std::exception& e) {
29827       {
29828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29829       };
29830     } catch (Dali::DaliException e) {
29831       {
29832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29833       };
29834     } catch (...) {
29835       {
29836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29837       };
29838     }
29839   }
29840
29841 }
29842
29843
29844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29845   void * jresult ;
29846   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29847   Dali::TouchData *arg2 = 0 ;
29848   Dali::TouchData *result = 0 ;
29849
29850   arg1 = (Dali::TouchData *)jarg1;
29851   arg2 = (Dali::TouchData *)jarg2;
29852   if (!arg2) {
29853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29854     return 0;
29855   }
29856   {
29857     try {
29858       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29859     } catch (std::out_of_range& e) {
29860       {
29861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29862       };
29863     } catch (std::exception& e) {
29864       {
29865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29866       };
29867     } catch (Dali::DaliException e) {
29868       {
29869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29870       };
29871     } catch (...) {
29872       {
29873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29874       };
29875     }
29876   }
29877
29878   jresult = (void *)result;
29879   return jresult;
29880 }
29881
29882
29883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29884   unsigned long jresult ;
29885   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29886   unsigned long result;
29887
29888   arg1 = (Dali::TouchData *)jarg1;
29889   {
29890     try {
29891       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29892     } catch (std::out_of_range& e) {
29893       {
29894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29895       };
29896     } catch (std::exception& e) {
29897       {
29898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29899       };
29900     } catch (Dali::DaliException e) {
29901       {
29902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29903       };
29904     } catch (...) {
29905       {
29906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29907       };
29908     }
29909   }
29910
29911   jresult = (unsigned long)result;
29912   return jresult;
29913 }
29914
29915
29916 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29917   unsigned long jresult ;
29918   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29919   std::size_t result;
29920
29921   arg1 = (Dali::TouchData *)jarg1;
29922   {
29923     try {
29924       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29925     } catch (std::out_of_range& e) {
29926       {
29927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29928       };
29929     } catch (std::exception& e) {
29930       {
29931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29932       };
29933     } catch (Dali::DaliException e) {
29934       {
29935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29936       };
29937     } catch (...) {
29938       {
29939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29940       };
29941     }
29942   }
29943
29944   jresult = (unsigned long)result;
29945   return jresult;
29946 }
29947
29948
29949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29950   int jresult ;
29951   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29952   std::size_t arg2 ;
29953   int32_t result;
29954
29955   arg1 = (Dali::TouchData *)jarg1;
29956   arg2 = (std::size_t)jarg2;
29957   {
29958     try {
29959       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29960     } catch (std::out_of_range& e) {
29961       {
29962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29963       };
29964     } catch (std::exception& e) {
29965       {
29966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29967       };
29968     } catch (Dali::DaliException e) {
29969       {
29970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29971       };
29972     } catch (...) {
29973       {
29974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29975       };
29976     }
29977   }
29978
29979   jresult = result;
29980   return jresult;
29981 }
29982
29983
29984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29985   int jresult ;
29986   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29987   std::size_t arg2 ;
29988   Dali::PointState::Type result;
29989
29990   arg1 = (Dali::TouchData *)jarg1;
29991   arg2 = (std::size_t)jarg2;
29992   {
29993     try {
29994       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29995     } catch (std::out_of_range& e) {
29996       {
29997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29998       };
29999     } catch (std::exception& e) {
30000       {
30001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30002       };
30003     } catch (Dali::DaliException e) {
30004       {
30005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30006       };
30007     } catch (...) {
30008       {
30009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30010       };
30011     }
30012   }
30013
30014   jresult = (int)result;
30015   return jresult;
30016 }
30017
30018
30019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30020   void * jresult ;
30021   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30022   std::size_t arg2 ;
30023   Dali::Actor result;
30024
30025   arg1 = (Dali::TouchData *)jarg1;
30026   arg2 = (std::size_t)jarg2;
30027   {
30028     try {
30029       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30030     } catch (std::out_of_range& e) {
30031       {
30032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30033       };
30034     } catch (std::exception& e) {
30035       {
30036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30037       };
30038     } catch (Dali::DaliException e) {
30039       {
30040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30041       };
30042     } catch (...) {
30043       {
30044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30045       };
30046     }
30047   }
30048
30049   jresult = new Dali::Actor((const Dali::Actor &)result);
30050   return jresult;
30051 }
30052
30053
30054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30055   void * jresult ;
30056   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30057   std::size_t arg2 ;
30058   Dali::Vector2 *result = 0 ;
30059
30060   arg1 = (Dali::TouchData *)jarg1;
30061   arg2 = (std::size_t)jarg2;
30062   {
30063     try {
30064       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30065     } catch (std::out_of_range& e) {
30066       {
30067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30068       };
30069     } catch (std::exception& e) {
30070       {
30071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30072       };
30073     } catch (Dali::DaliException e) {
30074       {
30075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30076       };
30077     } catch (...) {
30078       {
30079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30080       };
30081     }
30082   }
30083
30084   jresult = (void *)result;
30085   return jresult;
30086 }
30087
30088
30089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30090   void * jresult ;
30091   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30092   std::size_t arg2 ;
30093   Dali::Vector2 *result = 0 ;
30094
30095   arg1 = (Dali::TouchData *)jarg1;
30096   arg2 = (std::size_t)jarg2;
30097   {
30098     try {
30099       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30100     } catch (std::out_of_range& e) {
30101       {
30102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30103       };
30104     } catch (std::exception& e) {
30105       {
30106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30107       };
30108     } catch (Dali::DaliException e) {
30109       {
30110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30111       };
30112     } catch (...) {
30113       {
30114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30115       };
30116     }
30117   }
30118
30119   jresult = (void *)result;
30120   return jresult;
30121 }
30122
30123
30124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30125   float jresult ;
30126   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30127   std::size_t arg2 ;
30128   float result;
30129
30130   arg1 = (Dali::TouchData *)jarg1;
30131   arg2 = (std::size_t)jarg2;
30132   {
30133     try {
30134       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30135     } catch (std::out_of_range& e) {
30136       {
30137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30138       };
30139     } catch (std::exception& e) {
30140       {
30141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30142       };
30143     } catch (Dali::DaliException e) {
30144       {
30145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30146       };
30147     } catch (...) {
30148       {
30149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30150       };
30151     }
30152   }
30153
30154   jresult = result;
30155   return jresult;
30156 }
30157
30158
30159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30160   void * jresult ;
30161   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30162   std::size_t arg2 ;
30163   Dali::Vector2 *result = 0 ;
30164
30165   arg1 = (Dali::TouchData *)jarg1;
30166   arg2 = (std::size_t)jarg2;
30167   {
30168     try {
30169       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30170     } catch (std::out_of_range& e) {
30171       {
30172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30173       };
30174     } catch (std::exception& e) {
30175       {
30176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30177       };
30178     } catch (Dali::DaliException e) {
30179       {
30180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30181       };
30182     } catch (...) {
30183       {
30184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30185       };
30186     }
30187   }
30188
30189   jresult = (void *)result;
30190   return jresult;
30191 }
30192
30193
30194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30195   float jresult ;
30196   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30197   std::size_t arg2 ;
30198   float result;
30199
30200   arg1 = (Dali::TouchData *)jarg1;
30201   arg2 = (std::size_t)jarg2;
30202   {
30203     try {
30204       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30205     } catch (std::out_of_range& e) {
30206       {
30207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30208       };
30209     } catch (std::exception& e) {
30210       {
30211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30212       };
30213     } catch (Dali::DaliException e) {
30214       {
30215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30216       };
30217     } catch (...) {
30218       {
30219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30220       };
30221     }
30222   }
30223
30224   jresult = result;
30225   return jresult;
30226 }
30227
30228
30229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30230   void * jresult ;
30231   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30232   std::size_t arg2 ;
30233   Dali::Degree result;
30234
30235   arg1 = (Dali::TouchData *)jarg1;
30236   arg2 = (std::size_t)jarg2;
30237   {
30238     try {
30239       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30240     } catch (std::out_of_range& e) {
30241       {
30242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30243       };
30244     } catch (std::exception& e) {
30245       {
30246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30247       };
30248     } catch (Dali::DaliException e) {
30249       {
30250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30251       };
30252     } catch (...) {
30253       {
30254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30255       };
30256     }
30257   }
30258
30259   jresult = new Dali::Degree((const Dali::Degree &)result);
30260   return jresult;
30261 }
30262
30263
30264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30265   int jresult ;
30266   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30267   std::size_t arg2 ;
30268   Dali::MouseButton::Type result;
30269
30270   arg1 = (Dali::TouchData *)jarg1;
30271   arg2 = (std::size_t)jarg2;
30272   {
30273     try {
30274       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30275     } catch (std::out_of_range& e) {
30276       {
30277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30278       };
30279     } catch (std::exception& e) {
30280       {
30281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30282       };
30283     } catch (Dali::DaliException e) {
30284       {
30285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30286       };
30287     } catch (...) {
30288       {
30289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30290       };
30291     }
30292   }
30293
30294   jresult = static_cast< int >(result);
30295   return jresult;
30296 }
30297
30298
30299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30300   void * jresult ;
30301   Dali::GestureDetector *result = 0 ;
30302
30303   {
30304     try {
30305       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30306     } catch (std::out_of_range& e) {
30307       {
30308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30309       };
30310     } catch (std::exception& e) {
30311       {
30312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30313       };
30314     } catch (Dali::DaliException e) {
30315       {
30316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30317       };
30318     } catch (...) {
30319       {
30320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30321       };
30322     }
30323   }
30324
30325   jresult = (void *)result;
30326   return jresult;
30327 }
30328
30329
30330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30331   void * jresult ;
30332   Dali::BaseHandle arg1 ;
30333   Dali::BaseHandle *argp1 ;
30334   Dali::GestureDetector result;
30335
30336   argp1 = (Dali::BaseHandle *)jarg1;
30337   if (!argp1) {
30338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30339     return 0;
30340   }
30341   arg1 = *argp1;
30342   {
30343     try {
30344       result = Dali::GestureDetector::DownCast(arg1);
30345     } catch (std::out_of_range& e) {
30346       {
30347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30348       };
30349     } catch (std::exception& e) {
30350       {
30351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30352       };
30353     } catch (Dali::DaliException e) {
30354       {
30355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30356       };
30357     } catch (...) {
30358       {
30359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30360       };
30361     }
30362   }
30363
30364   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30365   return jresult;
30366 }
30367
30368
30369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30370   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30371
30372   arg1 = (Dali::GestureDetector *)jarg1;
30373   {
30374     try {
30375       delete arg1;
30376     } catch (std::out_of_range& e) {
30377       {
30378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30379       };
30380     } catch (std::exception& e) {
30381       {
30382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30383       };
30384     } catch (Dali::DaliException e) {
30385       {
30386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30387       };
30388     } catch (...) {
30389       {
30390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30391       };
30392     }
30393   }
30394
30395 }
30396
30397
30398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30399   void * jresult ;
30400   Dali::GestureDetector *arg1 = 0 ;
30401   Dali::GestureDetector *result = 0 ;
30402
30403   arg1 = (Dali::GestureDetector *)jarg1;
30404   if (!arg1) {
30405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30406     return 0;
30407   }
30408   {
30409     try {
30410       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30411     } catch (std::out_of_range& e) {
30412       {
30413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30414       };
30415     } catch (std::exception& e) {
30416       {
30417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30418       };
30419     } catch (Dali::DaliException e) {
30420       {
30421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30422       };
30423     } catch (...) {
30424       {
30425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30426       };
30427     }
30428   }
30429
30430   jresult = (void *)result;
30431   return jresult;
30432 }
30433
30434
30435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30436   void * jresult ;
30437   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30438   Dali::GestureDetector *arg2 = 0 ;
30439   Dali::GestureDetector *result = 0 ;
30440
30441   arg1 = (Dali::GestureDetector *)jarg1;
30442   arg2 = (Dali::GestureDetector *)jarg2;
30443   if (!arg2) {
30444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30445     return 0;
30446   }
30447   {
30448     try {
30449       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30450     } catch (std::out_of_range& e) {
30451       {
30452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30453       };
30454     } catch (std::exception& e) {
30455       {
30456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30457       };
30458     } catch (Dali::DaliException e) {
30459       {
30460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30461       };
30462     } catch (...) {
30463       {
30464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30465       };
30466     }
30467   }
30468
30469   jresult = (void *)result;
30470   return jresult;
30471 }
30472
30473
30474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30475   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30476   Dali::Actor arg2 ;
30477   Dali::Actor *argp2 ;
30478
30479   arg1 = (Dali::GestureDetector *)jarg1;
30480   argp2 = (Dali::Actor *)jarg2;
30481   if (!argp2) {
30482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30483     return ;
30484   }
30485   arg2 = *argp2;
30486   {
30487     try {
30488       (arg1)->Attach(arg2);
30489     } catch (std::out_of_range& e) {
30490       {
30491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30492       };
30493     } catch (std::exception& e) {
30494       {
30495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30496       };
30497     } catch (Dali::DaliException e) {
30498       {
30499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30500       };
30501     } catch (...) {
30502       {
30503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30504       };
30505     }
30506   }
30507
30508 }
30509
30510
30511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30512   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30513   Dali::Actor arg2 ;
30514   Dali::Actor *argp2 ;
30515
30516   arg1 = (Dali::GestureDetector *)jarg1;
30517   argp2 = (Dali::Actor *)jarg2;
30518   if (!argp2) {
30519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30520     return ;
30521   }
30522   arg2 = *argp2;
30523   {
30524     try {
30525       (arg1)->Detach(arg2);
30526     } catch (std::out_of_range& e) {
30527       {
30528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30529       };
30530     } catch (std::exception& e) {
30531       {
30532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30533       };
30534     } catch (Dali::DaliException e) {
30535       {
30536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30537       };
30538     } catch (...) {
30539       {
30540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30541       };
30542     }
30543   }
30544
30545 }
30546
30547
30548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30549   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30550
30551   arg1 = (Dali::GestureDetector *)jarg1;
30552   {
30553     try {
30554       (arg1)->DetachAll();
30555     } catch (std::out_of_range& e) {
30556       {
30557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30558       };
30559     } catch (std::exception& e) {
30560       {
30561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30562       };
30563     } catch (Dali::DaliException e) {
30564       {
30565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30566       };
30567     } catch (...) {
30568       {
30569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30570       };
30571     }
30572   }
30573
30574 }
30575
30576
30577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30578   unsigned long jresult ;
30579   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30580   size_t result;
30581
30582   arg1 = (Dali::GestureDetector *)jarg1;
30583   {
30584     try {
30585       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30586     } catch (std::out_of_range& e) {
30587       {
30588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30589       };
30590     } catch (std::exception& e) {
30591       {
30592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30593       };
30594     } catch (Dali::DaliException e) {
30595       {
30596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30597       };
30598     } catch (...) {
30599       {
30600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30601       };
30602     }
30603   }
30604
30605   jresult = (unsigned long)result;
30606   return jresult;
30607 }
30608
30609
30610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30611   void * jresult ;
30612   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30613   size_t arg2 ;
30614   Dali::Actor result;
30615
30616   arg1 = (Dali::GestureDetector *)jarg1;
30617   arg2 = (size_t)jarg2;
30618   {
30619     try {
30620       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30621     } catch (std::out_of_range& e) {
30622       {
30623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30624       };
30625     } catch (std::exception& e) {
30626       {
30627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30628       };
30629     } catch (Dali::DaliException e) {
30630       {
30631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30632       };
30633     } catch (...) {
30634       {
30635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30636       };
30637     }
30638   }
30639
30640   jresult = new Dali::Actor((const Dali::Actor &)result);
30641   return jresult;
30642 }
30643
30644
30645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30646   void * jresult ;
30647   Dali::Gesture *arg1 = 0 ;
30648   Dali::Gesture *result = 0 ;
30649
30650   arg1 = (Dali::Gesture *)jarg1;
30651   if (!arg1) {
30652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30653     return 0;
30654   }
30655   {
30656     try {
30657       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30658     } catch (std::out_of_range& e) {
30659       {
30660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30661       };
30662     } catch (std::exception& e) {
30663       {
30664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30665       };
30666     } catch (Dali::DaliException e) {
30667       {
30668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30669       };
30670     } catch (...) {
30671       {
30672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30673       };
30674     }
30675   }
30676
30677   jresult = (void *)result;
30678   return jresult;
30679 }
30680
30681
30682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30683   void * jresult ;
30684   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30685   Dali::Gesture *arg2 = 0 ;
30686   Dali::Gesture *result = 0 ;
30687
30688   arg1 = (Dali::Gesture *)jarg1;
30689   arg2 = (Dali::Gesture *)jarg2;
30690   if (!arg2) {
30691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30692     return 0;
30693   }
30694   {
30695     try {
30696       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30697     } catch (std::out_of_range& e) {
30698       {
30699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30700       };
30701     } catch (std::exception& e) {
30702       {
30703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30704       };
30705     } catch (Dali::DaliException e) {
30706       {
30707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30708       };
30709     } catch (...) {
30710       {
30711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30712       };
30713     }
30714   }
30715
30716   jresult = (void *)result;
30717   return jresult;
30718 }
30719
30720
30721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30722   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30723
30724   arg1 = (Dali::Gesture *)jarg1;
30725   {
30726     try {
30727       delete arg1;
30728     } catch (std::out_of_range& e) {
30729       {
30730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30731       };
30732     } catch (std::exception& e) {
30733       {
30734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30735       };
30736     } catch (Dali::DaliException e) {
30737       {
30738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30739       };
30740     } catch (...) {
30741       {
30742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30743       };
30744     }
30745   }
30746
30747 }
30748
30749
30750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30751   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30752   Dali::Gesture::Type arg2 ;
30753
30754   arg1 = (Dali::Gesture *)jarg1;
30755   arg2 = (Dali::Gesture::Type)jarg2;
30756   if (arg1) (arg1)->type = arg2;
30757 }
30758
30759
30760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30761   int jresult ;
30762   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30763   Dali::Gesture::Type result;
30764
30765   arg1 = (Dali::Gesture *)jarg1;
30766   result = (Dali::Gesture::Type) ((arg1)->type);
30767   jresult = (int)result;
30768   return jresult;
30769 }
30770
30771
30772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30773   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30774   Dali::Gesture::State arg2 ;
30775
30776   arg1 = (Dali::Gesture *)jarg1;
30777   arg2 = (Dali::Gesture::State)jarg2;
30778   if (arg1) (arg1)->state = arg2;
30779 }
30780
30781
30782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30783   int jresult ;
30784   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30785   Dali::Gesture::State result;
30786
30787   arg1 = (Dali::Gesture *)jarg1;
30788   result = (Dali::Gesture::State) ((arg1)->state);
30789   jresult = (int)result;
30790   return jresult;
30791 }
30792
30793
30794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30795   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30796   unsigned int arg2 ;
30797
30798   arg1 = (Dali::Gesture *)jarg1;
30799   arg2 = (unsigned int)jarg2;
30800   if (arg1) (arg1)->time = arg2;
30801 }
30802
30803
30804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30805   unsigned int jresult ;
30806   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30807   unsigned int result;
30808
30809   arg1 = (Dali::Gesture *)jarg1;
30810   result = (unsigned int) ((arg1)->time);
30811   jresult = result;
30812   return jresult;
30813 }
30814
30815
30816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30817   void * jresult ;
30818   Dali::HoverEvent *result = 0 ;
30819
30820   {
30821     try {
30822       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30823     } catch (std::out_of_range& e) {
30824       {
30825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30826       };
30827     } catch (std::exception& e) {
30828       {
30829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30830       };
30831     } catch (Dali::DaliException e) {
30832       {
30833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30834       };
30835     } catch (...) {
30836       {
30837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30838       };
30839     }
30840   }
30841
30842   jresult = (void *)result;
30843   return jresult;
30844 }
30845
30846
30847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30848   void * jresult ;
30849   unsigned long arg1 ;
30850   Dali::HoverEvent *result = 0 ;
30851
30852   arg1 = (unsigned long)jarg1;
30853   {
30854     try {
30855       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30856     } catch (std::out_of_range& e) {
30857       {
30858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30859       };
30860     } catch (std::exception& e) {
30861       {
30862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30863       };
30864     } catch (Dali::DaliException e) {
30865       {
30866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30867       };
30868     } catch (...) {
30869       {
30870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30871       };
30872     }
30873   }
30874
30875   jresult = (void *)result;
30876   return jresult;
30877 }
30878
30879
30880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30881   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30882
30883   arg1 = (Dali::HoverEvent *)jarg1;
30884   {
30885     try {
30886       delete arg1;
30887     } catch (std::out_of_range& e) {
30888       {
30889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30890       };
30891     } catch (std::exception& e) {
30892       {
30893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30894       };
30895     } catch (Dali::DaliException e) {
30896       {
30897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30898       };
30899     } catch (...) {
30900       {
30901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30902       };
30903     }
30904   }
30905
30906 }
30907
30908
30909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30910   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30911   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30912
30913   arg1 = (Dali::HoverEvent *)jarg1;
30914   arg2 = (Dali::TouchPointContainer *)jarg2;
30915   if (arg1) (arg1)->points = *arg2;
30916 }
30917
30918
30919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30920   void * jresult ;
30921   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30922   Dali::TouchPointContainer *result = 0 ;
30923
30924   arg1 = (Dali::HoverEvent *)jarg1;
30925   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30926   jresult = (void *)result;
30927   return jresult;
30928 }
30929
30930
30931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30932   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30933   unsigned long arg2 ;
30934
30935   arg1 = (Dali::HoverEvent *)jarg1;
30936   arg2 = (unsigned long)jarg2;
30937   if (arg1) (arg1)->time = arg2;
30938 }
30939
30940
30941 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30942   unsigned long jresult ;
30943   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30944   unsigned long result;
30945
30946   arg1 = (Dali::HoverEvent *)jarg1;
30947   result = (unsigned long) ((arg1)->time);
30948   jresult = (unsigned long)result;
30949   return jresult;
30950 }
30951
30952
30953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30954   unsigned int jresult ;
30955   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30956   unsigned int result;
30957
30958   arg1 = (Dali::HoverEvent *)jarg1;
30959   {
30960     try {
30961       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30962     } catch (std::out_of_range& e) {
30963       {
30964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30965       };
30966     } catch (std::exception& e) {
30967       {
30968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30969       };
30970     } catch (Dali::DaliException e) {
30971       {
30972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30973       };
30974     } catch (...) {
30975       {
30976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30977       };
30978     }
30979   }
30980
30981   jresult = result;
30982   return jresult;
30983 }
30984
30985
30986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30987   void * jresult ;
30988   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30989   unsigned int arg2 ;
30990   Dali::TouchPoint *result = 0 ;
30991
30992   arg1 = (Dali::HoverEvent *)jarg1;
30993   arg2 = (unsigned int)jarg2;
30994   {
30995     try {
30996       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30997     } catch (std::out_of_range& e) {
30998       {
30999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31000       };
31001     } catch (std::exception& e) {
31002       {
31003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31004       };
31005     } catch (Dali::DaliException e) {
31006       {
31007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31008       };
31009     } catch (...) {
31010       {
31011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31012       };
31013     }
31014   }
31015
31016   jresult = (void *)result;
31017   return jresult;
31018 }
31019
31020
31021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31022   void * jresult ;
31023   Dali::KeyEvent *result = 0 ;
31024
31025   {
31026     try {
31027       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31028     } catch (std::out_of_range& e) {
31029       {
31030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31031       };
31032     } catch (std::exception& e) {
31033       {
31034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31035       };
31036     } catch (Dali::DaliException e) {
31037       {
31038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31039       };
31040     } catch (...) {
31041       {
31042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31043       };
31044     }
31045   }
31046
31047   jresult = (void *)result;
31048   return jresult;
31049 }
31050
31051
31052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31053   void * jresult ;
31054   std::string *arg1 = 0 ;
31055   std::string *arg2 = 0 ;
31056   int arg3 ;
31057   int arg4 ;
31058   unsigned long arg5 ;
31059   Dali::KeyEvent::State *arg6 = 0 ;
31060   Dali::KeyEvent::State temp6 ;
31061   Dali::KeyEvent *result = 0 ;
31062
31063   if (!jarg1) {
31064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31065     return 0;
31066   }
31067   std::string arg1_str(jarg1);
31068   arg1 = &arg1_str;
31069   if (!jarg2) {
31070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31071     return 0;
31072   }
31073   std::string arg2_str(jarg2);
31074   arg2 = &arg2_str;
31075   arg3 = (int)jarg3;
31076   arg4 = (int)jarg4;
31077   arg5 = (unsigned long)jarg5;
31078   temp6 = (Dali::KeyEvent::State)jarg6;
31079   arg6 = &temp6;
31080   {
31081     try {
31082       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31083     } catch (std::out_of_range& e) {
31084       {
31085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31086       };
31087     } catch (std::exception& e) {
31088       {
31089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31090       };
31091     } catch (Dali::DaliException e) {
31092       {
31093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31094       };
31095     } catch (...) {
31096       {
31097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31098       };
31099     }
31100   }
31101
31102   jresult = (void *)result;
31103
31104   //argout typemap for const std::string&
31105
31106
31107   //argout typemap for const std::string&
31108
31109   return jresult;
31110 }
31111
31112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31113   void * jresult ;
31114   Dali::KeyEvent *arg1 = 0 ;
31115   Dali::KeyEvent *result = 0 ;
31116
31117   arg1 = (Dali::KeyEvent *)jarg1;
31118   if (!arg1) {
31119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31120     return 0;
31121   }
31122   {
31123     try {
31124       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31125     } catch (std::out_of_range& e) {
31126       {
31127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31128       };
31129     } catch (std::exception& e) {
31130       {
31131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31132       };
31133     } catch (Dali::DaliException e) {
31134       {
31135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31136       };
31137     } catch (...) {
31138       {
31139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31140       };
31141     }
31142   }
31143
31144   jresult = (void *)result;
31145   return jresult;
31146 }
31147
31148
31149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31150   void * jresult ;
31151   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31152   Dali::KeyEvent *arg2 = 0 ;
31153   Dali::KeyEvent *result = 0 ;
31154
31155   arg1 = (Dali::KeyEvent *)jarg1;
31156   arg2 = (Dali::KeyEvent *)jarg2;
31157   if (!arg2) {
31158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31159     return 0;
31160   }
31161   {
31162     try {
31163       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31164     } catch (std::out_of_range& e) {
31165       {
31166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31167       };
31168     } catch (std::exception& e) {
31169       {
31170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31171       };
31172     } catch (Dali::DaliException e) {
31173       {
31174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31175       };
31176     } catch (...) {
31177       {
31178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31179       };
31180     }
31181   }
31182
31183   jresult = (void *)result;
31184   return jresult;
31185 }
31186
31187
31188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31189   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31190
31191   arg1 = (Dali::KeyEvent *)jarg1;
31192   {
31193     try {
31194       delete arg1;
31195     } catch (std::out_of_range& e) {
31196       {
31197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31198       };
31199     } catch (std::exception& e) {
31200       {
31201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31202       };
31203     } catch (Dali::DaliException e) {
31204       {
31205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31206       };
31207     } catch (...) {
31208       {
31209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31210       };
31211     }
31212   }
31213
31214 }
31215
31216
31217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31218   unsigned int jresult ;
31219   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31220   bool result;
31221
31222   arg1 = (Dali::KeyEvent *)jarg1;
31223   {
31224     try {
31225       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31226     } catch (std::out_of_range& e) {
31227       {
31228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31229       };
31230     } catch (std::exception& e) {
31231       {
31232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31233       };
31234     } catch (Dali::DaliException e) {
31235       {
31236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31237       };
31238     } catch (...) {
31239       {
31240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31241       };
31242     }
31243   }
31244
31245   jresult = result;
31246   return jresult;
31247 }
31248
31249
31250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31251   unsigned int jresult ;
31252   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31253   bool result;
31254
31255   arg1 = (Dali::KeyEvent *)jarg1;
31256   {
31257     try {
31258       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31259     } catch (std::out_of_range& e) {
31260       {
31261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31262       };
31263     } catch (std::exception& e) {
31264       {
31265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31266       };
31267     } catch (Dali::DaliException e) {
31268       {
31269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31270       };
31271     } catch (...) {
31272       {
31273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31274       };
31275     }
31276   }
31277
31278   jresult = result;
31279   return jresult;
31280 }
31281
31282
31283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31284   unsigned int jresult ;
31285   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31286   bool result;
31287
31288   arg1 = (Dali::KeyEvent *)jarg1;
31289   {
31290     try {
31291       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31292     } catch (std::out_of_range& e) {
31293       {
31294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31295       };
31296     } catch (std::exception& e) {
31297       {
31298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31299       };
31300     } catch (Dali::DaliException e) {
31301       {
31302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31303       };
31304     } catch (...) {
31305       {
31306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31307       };
31308     }
31309   }
31310
31311   jresult = result;
31312   return jresult;
31313 }
31314
31315
31316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31317   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31318   std::string *arg2 = 0 ;
31319
31320   arg1 = (Dali::KeyEvent *)jarg1;
31321   if (!jarg2) {
31322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31323     return ;
31324   }
31325   std::string arg2_str(jarg2);
31326   arg2 = &arg2_str;
31327   if (arg1) (arg1)->keyPressedName = *arg2;
31328
31329   //argout typemap for const std::string&
31330
31331 }
31332
31333
31334 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31335   char * jresult ;
31336
31337   if( jarg1 == NULL )
31338   {
31339     jresult = SWIG_csharp_string_callback( "" );
31340   }
31341   else
31342   {
31343     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31344     std::string *result = 0;
31345
31346     arg1 = ( Dali::KeyEvent * )jarg1;
31347     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31348     jresult = SWIG_csharp_string_callback( result->c_str() );
31349   }
31350
31351   return jresult;
31352 }
31353
31354
31355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31356   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31357   std::string *arg2 = 0 ;
31358
31359   arg1 = (Dali::KeyEvent *)jarg1;
31360   if (!jarg2) {
31361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31362     return ;
31363   }
31364   std::string arg2_str(jarg2);
31365   arg2 = &arg2_str;
31366   if (arg1) (arg1)->keyPressed = *arg2;
31367
31368   //argout typemap for const std::string&
31369
31370 }
31371
31372
31373 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31374   char * jresult ;
31375   if( NULL == jarg1 )
31376   {
31377     jresult = SWIG_csharp_string_callback( "" );
31378   }
31379   else
31380   {
31381     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31382     std::string *result = 0;
31383
31384     arg1 = ( Dali::KeyEvent * )jarg1;
31385     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31386     jresult = SWIG_csharp_string_callback( result->c_str() );
31387   }
31388   return jresult;
31389 }
31390
31391
31392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31393   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31394   int arg2 ;
31395
31396   arg1 = (Dali::KeyEvent *)jarg1;
31397   arg2 = (int)jarg2;
31398   if (arg1) (arg1)->keyCode = arg2;
31399 }
31400
31401
31402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31403   int jresult ;
31404   if( NULL == jarg1 )
31405   {
31406     jresult = -1;
31407   }
31408   else
31409   {
31410     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31411     int result;
31412
31413     arg1 = ( Dali::KeyEvent * )jarg1;
31414     result = (int)( ( arg1 )->keyCode );
31415     jresult = result;
31416   }
31417   return jresult;
31418 }
31419
31420
31421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31422   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31423   int arg2 ;
31424
31425   arg1 = (Dali::KeyEvent *)jarg1;
31426   arg2 = (int)jarg2;
31427   if (arg1) (arg1)->keyModifier = arg2;
31428 }
31429
31430
31431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31432   int jresult ;
31433   if( jarg1 == NULL )
31434   {
31435     jresult = -1;
31436   }
31437   else
31438   {
31439     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31440     int result;
31441
31442     arg1 = ( Dali::KeyEvent * )jarg1;
31443     result = (int)( ( arg1 )->keyModifier );
31444     jresult = result;
31445   }
31446   return jresult;
31447 }
31448
31449
31450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31451   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31452   unsigned long arg2 ;
31453
31454   arg1 = (Dali::KeyEvent *)jarg1;
31455   arg2 = (unsigned long)jarg2;
31456   if (arg1) (arg1)->time = arg2;
31457 }
31458
31459
31460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31461   unsigned long jresult ;
31462   if( jarg1 == NULL )
31463   {
31464     jresult = 0;
31465   }
31466   else
31467   {
31468     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31469     unsigned long result;
31470
31471     arg1 = ( Dali::KeyEvent * )jarg1;
31472     result = (unsigned long)( ( arg1 )->time );
31473     jresult = (unsigned long)result;
31474   }
31475   return jresult;
31476 }
31477
31478
31479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31480   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31481   Dali::KeyEvent::State arg2 ;
31482
31483   arg1 = (Dali::KeyEvent *)jarg1;
31484   arg2 = (Dali::KeyEvent::State)jarg2;
31485   if (arg1) (arg1)->state = arg2;
31486 }
31487
31488
31489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31490   int jresult ;
31491   if( jarg1 == NULL )
31492   {
31493     jresult = -1;
31494   }
31495   else
31496   {
31497     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31498     Dali::KeyEvent::State result;
31499
31500     arg1 = ( Dali::KeyEvent * )jarg1;
31501     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31502     jresult = (int)result;
31503   }
31504   return jresult;
31505 }
31506
31507 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31508   char * jresult ;
31509   std::string result;
31510   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31511
31512   arg1 = (Dali::KeyEvent *)jarg1;
31513   if (!arg1) {
31514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31515     return 0;
31516   }
31517   {
31518     try {
31519       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31520     } catch (std::out_of_range& e) {
31521       {
31522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31523       };
31524     } catch (std::exception& e) {
31525       {
31526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31527       };
31528     } catch (Dali::DaliException e) {
31529       {
31530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31531       };
31532     } catch (...) {
31533       {
31534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31535       };
31536     }
31537
31538   }
31539
31540   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31541   return jresult;
31542 }
31543
31544
31545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31546   void * jresult ;
31547   Dali::LongPressGestureDetector *result = 0 ;
31548
31549   {
31550     try {
31551       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31552     } catch (std::out_of_range& e) {
31553       {
31554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31555       };
31556     } catch (std::exception& e) {
31557       {
31558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31559       };
31560     } catch (Dali::DaliException e) {
31561       {
31562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31563       };
31564     } catch (...) {
31565       {
31566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31567       };
31568     }
31569   }
31570
31571   jresult = (void *)result;
31572   return jresult;
31573 }
31574
31575
31576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31577   void * jresult ;
31578   Dali::LongPressGestureDetector result;
31579
31580   {
31581     try {
31582       result = Dali::LongPressGestureDetector::New();
31583     } catch (std::out_of_range& e) {
31584       {
31585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31586       };
31587     } catch (std::exception& e) {
31588       {
31589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31590       };
31591     } catch (Dali::DaliException e) {
31592       {
31593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31594       };
31595     } catch (...) {
31596       {
31597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31598       };
31599     }
31600   }
31601
31602   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31603   return jresult;
31604 }
31605
31606
31607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31608   void * jresult ;
31609   unsigned int arg1 ;
31610   Dali::LongPressGestureDetector result;
31611
31612   arg1 = (unsigned int)jarg1;
31613   {
31614     try {
31615       result = Dali::LongPressGestureDetector::New(arg1);
31616     } catch (std::out_of_range& e) {
31617       {
31618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31619       };
31620     } catch (std::exception& e) {
31621       {
31622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31623       };
31624     } catch (Dali::DaliException e) {
31625       {
31626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31627       };
31628     } catch (...) {
31629       {
31630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31631       };
31632     }
31633   }
31634
31635   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31636   return jresult;
31637 }
31638
31639
31640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31641   void * jresult ;
31642   unsigned int arg1 ;
31643   unsigned int arg2 ;
31644   Dali::LongPressGestureDetector result;
31645
31646   arg1 = (unsigned int)jarg1;
31647   arg2 = (unsigned int)jarg2;
31648   {
31649     try {
31650       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31651     } catch (std::out_of_range& e) {
31652       {
31653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31654       };
31655     } catch (std::exception& e) {
31656       {
31657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31658       };
31659     } catch (Dali::DaliException e) {
31660       {
31661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31662       };
31663     } catch (...) {
31664       {
31665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31666       };
31667     }
31668   }
31669
31670   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31671   return jresult;
31672 }
31673
31674
31675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31676   void * jresult ;
31677   Dali::BaseHandle arg1 ;
31678   Dali::BaseHandle *argp1 ;
31679   Dali::LongPressGestureDetector result;
31680
31681   argp1 = (Dali::BaseHandle *)jarg1;
31682   if (!argp1) {
31683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31684     return 0;
31685   }
31686   arg1 = *argp1;
31687   {
31688     try {
31689       result = Dali::LongPressGestureDetector::DownCast(arg1);
31690     } catch (std::out_of_range& e) {
31691       {
31692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31693       };
31694     } catch (std::exception& e) {
31695       {
31696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31697       };
31698     } catch (Dali::DaliException e) {
31699       {
31700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31701       };
31702     } catch (...) {
31703       {
31704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31705       };
31706     }
31707   }
31708
31709   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31710   return jresult;
31711 }
31712
31713
31714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31715   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31716
31717   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31718   {
31719     try {
31720       delete arg1;
31721     } catch (std::out_of_range& e) {
31722       {
31723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31724       };
31725     } catch (std::exception& e) {
31726       {
31727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31728       };
31729     } catch (Dali::DaliException e) {
31730       {
31731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31732       };
31733     } catch (...) {
31734       {
31735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31736       };
31737     }
31738   }
31739
31740 }
31741
31742
31743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31744   void * jresult ;
31745   Dali::LongPressGestureDetector *arg1 = 0 ;
31746   Dali::LongPressGestureDetector *result = 0 ;
31747
31748   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31749   if (!arg1) {
31750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31751     return 0;
31752   }
31753   {
31754     try {
31755       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31756     } catch (std::out_of_range& e) {
31757       {
31758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31759       };
31760     } catch (std::exception& e) {
31761       {
31762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31763       };
31764     } catch (Dali::DaliException e) {
31765       {
31766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31767       };
31768     } catch (...) {
31769       {
31770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31771       };
31772     }
31773   }
31774
31775   jresult = (void *)result;
31776   return jresult;
31777 }
31778
31779
31780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31781   void * jresult ;
31782   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31783   Dali::LongPressGestureDetector *arg2 = 0 ;
31784   Dali::LongPressGestureDetector *result = 0 ;
31785
31786   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31787   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31788   if (!arg2) {
31789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31790     return 0;
31791   }
31792   {
31793     try {
31794       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31795     } catch (std::out_of_range& e) {
31796       {
31797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31798       };
31799     } catch (std::exception& e) {
31800       {
31801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31802       };
31803     } catch (Dali::DaliException e) {
31804       {
31805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31806       };
31807     } catch (...) {
31808       {
31809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31810       };
31811     }
31812   }
31813
31814   jresult = (void *)result;
31815   return jresult;
31816 }
31817
31818
31819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31820   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31821   unsigned int arg2 ;
31822
31823   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31824   arg2 = (unsigned int)jarg2;
31825   {
31826     try {
31827       (arg1)->SetTouchesRequired(arg2);
31828     } catch (std::out_of_range& e) {
31829       {
31830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31831       };
31832     } catch (std::exception& e) {
31833       {
31834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31835       };
31836     } catch (Dali::DaliException e) {
31837       {
31838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31839       };
31840     } catch (...) {
31841       {
31842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31843       };
31844     }
31845   }
31846
31847 }
31848
31849
31850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31851   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31852   unsigned int arg2 ;
31853   unsigned int arg3 ;
31854
31855   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31856   arg2 = (unsigned int)jarg2;
31857   arg3 = (unsigned int)jarg3;
31858   {
31859     try {
31860       (arg1)->SetTouchesRequired(arg2,arg3);
31861     } catch (std::out_of_range& e) {
31862       {
31863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31864       };
31865     } catch (std::exception& e) {
31866       {
31867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31868       };
31869     } catch (Dali::DaliException e) {
31870       {
31871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31872       };
31873     } catch (...) {
31874       {
31875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31876       };
31877     }
31878   }
31879
31880 }
31881
31882
31883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31884   unsigned int jresult ;
31885   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31886   unsigned int result;
31887
31888   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31889   {
31890     try {
31891       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31892     } catch (std::out_of_range& e) {
31893       {
31894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31895       };
31896     } catch (std::exception& e) {
31897       {
31898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31899       };
31900     } catch (Dali::DaliException e) {
31901       {
31902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31903       };
31904     } catch (...) {
31905       {
31906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31907       };
31908     }
31909   }
31910
31911   jresult = result;
31912   return jresult;
31913 }
31914
31915
31916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31917   unsigned int jresult ;
31918   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31919   unsigned int result;
31920
31921   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31922   {
31923     try {
31924       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31925     } catch (std::out_of_range& e) {
31926       {
31927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31928       };
31929     } catch (std::exception& e) {
31930       {
31931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31932       };
31933     } catch (Dali::DaliException e) {
31934       {
31935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31936       };
31937     } catch (...) {
31938       {
31939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31940       };
31941     }
31942   }
31943
31944   jresult = result;
31945   return jresult;
31946 }
31947
31948
31949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31950   void * jresult ;
31951   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31952   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31953
31954   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31955   {
31956     try {
31957       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31958     } catch (std::out_of_range& e) {
31959       {
31960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31961       };
31962     } catch (std::exception& e) {
31963       {
31964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31965       };
31966     } catch (Dali::DaliException e) {
31967       {
31968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31969       };
31970     } catch (...) {
31971       {
31972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31973       };
31974     }
31975   }
31976
31977   jresult = (void *)result;
31978   return jresult;
31979 }
31980
31981
31982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31983   void * jresult ;
31984   Dali::Gesture::State arg1 ;
31985   Dali::LongPressGesture *result = 0 ;
31986
31987   arg1 = (Dali::Gesture::State)jarg1;
31988   {
31989     try {
31990       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31991     } catch (std::out_of_range& e) {
31992       {
31993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31994       };
31995     } catch (std::exception& e) {
31996       {
31997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31998       };
31999     } catch (Dali::DaliException e) {
32000       {
32001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32002       };
32003     } catch (...) {
32004       {
32005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32006       };
32007     }
32008   }
32009
32010   jresult = (void *)result;
32011   return jresult;
32012 }
32013
32014
32015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32016   void * jresult ;
32017   Dali::LongPressGesture *arg1 = 0 ;
32018   Dali::LongPressGesture *result = 0 ;
32019
32020   arg1 = (Dali::LongPressGesture *)jarg1;
32021   if (!arg1) {
32022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32023     return 0;
32024   }
32025   {
32026     try {
32027       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32028     } catch (std::out_of_range& e) {
32029       {
32030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32031       };
32032     } catch (std::exception& e) {
32033       {
32034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32035       };
32036     } catch (Dali::DaliException e) {
32037       {
32038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32039       };
32040     } catch (...) {
32041       {
32042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32043       };
32044     }
32045   }
32046
32047   jresult = (void *)result;
32048   return jresult;
32049 }
32050
32051
32052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32053   void * jresult ;
32054   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32055   Dali::LongPressGesture *arg2 = 0 ;
32056   Dali::LongPressGesture *result = 0 ;
32057
32058   arg1 = (Dali::LongPressGesture *)jarg1;
32059   arg2 = (Dali::LongPressGesture *)jarg2;
32060   if (!arg2) {
32061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32062     return 0;
32063   }
32064   {
32065     try {
32066       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32067     } catch (std::out_of_range& e) {
32068       {
32069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32070       };
32071     } catch (std::exception& e) {
32072       {
32073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32074       };
32075     } catch (Dali::DaliException e) {
32076       {
32077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32078       };
32079     } catch (...) {
32080       {
32081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32082       };
32083     }
32084   }
32085
32086   jresult = (void *)result;
32087   return jresult;
32088 }
32089
32090
32091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32092   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32093
32094   arg1 = (Dali::LongPressGesture *)jarg1;
32095   {
32096     try {
32097       delete arg1;
32098     } catch (std::out_of_range& e) {
32099       {
32100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32101       };
32102     } catch (std::exception& e) {
32103       {
32104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32105       };
32106     } catch (Dali::DaliException e) {
32107       {
32108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32109       };
32110     } catch (...) {
32111       {
32112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32113       };
32114     }
32115   }
32116
32117 }
32118
32119
32120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32121   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32122   unsigned int arg2 ;
32123
32124   arg1 = (Dali::LongPressGesture *)jarg1;
32125   arg2 = (unsigned int)jarg2;
32126   if (arg1) (arg1)->numberOfTouches = arg2;
32127 }
32128
32129
32130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32131   unsigned int jresult ;
32132   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32133   unsigned int result;
32134
32135   arg1 = (Dali::LongPressGesture *)jarg1;
32136   result = (unsigned int) ((arg1)->numberOfTouches);
32137   jresult = result;
32138   return jresult;
32139 }
32140
32141
32142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32143   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32144   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32145
32146   arg1 = (Dali::LongPressGesture *)jarg1;
32147   arg2 = (Dali::Vector2 *)jarg2;
32148   if (arg1) (arg1)->screenPoint = *arg2;
32149 }
32150
32151
32152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32153   void * jresult ;
32154   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32155   Dali::Vector2 *result = 0 ;
32156
32157   arg1 = (Dali::LongPressGesture *)jarg1;
32158   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32159   jresult = (void *)result;
32160   return jresult;
32161 }
32162
32163
32164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32165   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32166   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32167
32168   arg1 = (Dali::LongPressGesture *)jarg1;
32169   arg2 = (Dali::Vector2 *)jarg2;
32170   if (arg1) (arg1)->localPoint = *arg2;
32171 }
32172
32173
32174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32175   void * jresult ;
32176   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32177   Dali::Vector2 *result = 0 ;
32178
32179   arg1 = (Dali::LongPressGesture *)jarg1;
32180   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32181   jresult = (void *)result;
32182   return jresult;
32183 }
32184
32185
32186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32187   void * jresult ;
32188   Dali::WheelEvent *result = 0 ;
32189
32190   {
32191     try {
32192       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32193     } catch (std::out_of_range& e) {
32194       {
32195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32196       };
32197     } catch (std::exception& e) {
32198       {
32199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32200       };
32201     } catch (Dali::DaliException e) {
32202       {
32203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32204       };
32205     } catch (...) {
32206       {
32207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32208       };
32209     }
32210   }
32211
32212   jresult = (void *)result;
32213   return jresult;
32214 }
32215
32216
32217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32218   void * jresult ;
32219   Dali::WheelEvent::Type arg1 ;
32220   int arg2 ;
32221   unsigned int arg3 ;
32222   Dali::Vector2 arg4 ;
32223   int arg5 ;
32224   unsigned int arg6 ;
32225   Dali::Vector2 *argp4 ;
32226   Dali::WheelEvent *result = 0 ;
32227
32228   arg1 = (Dali::WheelEvent::Type)jarg1;
32229   arg2 = (int)jarg2;
32230   arg3 = (unsigned int)jarg3;
32231   argp4 = (Dali::Vector2 *)jarg4;
32232   if (!argp4) {
32233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32234     return 0;
32235   }
32236   arg4 = *argp4;
32237   arg5 = (int)jarg5;
32238   arg6 = (unsigned int)jarg6;
32239   {
32240     try {
32241       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32242     } catch (std::out_of_range& e) {
32243       {
32244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32245       };
32246     } catch (std::exception& e) {
32247       {
32248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32249       };
32250     } catch (Dali::DaliException e) {
32251       {
32252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32253       };
32254     } catch (...) {
32255       {
32256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32257       };
32258     }
32259   }
32260
32261   jresult = (void *)result;
32262   return jresult;
32263 }
32264
32265
32266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32267   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32268
32269   arg1 = (Dali::WheelEvent *)jarg1;
32270   {
32271     try {
32272       delete arg1;
32273     } catch (std::out_of_range& e) {
32274       {
32275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32276       };
32277     } catch (std::exception& e) {
32278       {
32279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32280       };
32281     } catch (Dali::DaliException e) {
32282       {
32283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32284       };
32285     } catch (...) {
32286       {
32287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32288       };
32289     }
32290   }
32291
32292 }
32293
32294
32295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32296   unsigned int jresult ;
32297   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32298   bool result;
32299
32300   arg1 = (Dali::WheelEvent *)jarg1;
32301   {
32302     try {
32303       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32304     } catch (std::out_of_range& e) {
32305       {
32306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32307       };
32308     } catch (std::exception& e) {
32309       {
32310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32311       };
32312     } catch (Dali::DaliException e) {
32313       {
32314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32315       };
32316     } catch (...) {
32317       {
32318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32319       };
32320     }
32321   }
32322
32323   jresult = result;
32324   return jresult;
32325 }
32326
32327
32328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32329   unsigned int jresult ;
32330   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32331   bool result;
32332
32333   arg1 = (Dali::WheelEvent *)jarg1;
32334   {
32335     try {
32336       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32337     } catch (std::out_of_range& e) {
32338       {
32339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32340       };
32341     } catch (std::exception& e) {
32342       {
32343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32344       };
32345     } catch (Dali::DaliException e) {
32346       {
32347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32348       };
32349     } catch (...) {
32350       {
32351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32352       };
32353     }
32354   }
32355
32356   jresult = result;
32357   return jresult;
32358 }
32359
32360
32361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32362   unsigned int jresult ;
32363   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32364   bool result;
32365
32366   arg1 = (Dali::WheelEvent *)jarg1;
32367   {
32368     try {
32369       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32370     } catch (std::out_of_range& e) {
32371       {
32372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32373       };
32374     } catch (std::exception& e) {
32375       {
32376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32377       };
32378     } catch (Dali::DaliException e) {
32379       {
32380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32381       };
32382     } catch (...) {
32383       {
32384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32385       };
32386     }
32387   }
32388
32389   jresult = result;
32390   return jresult;
32391 }
32392
32393
32394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32395   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32396   Dali::WheelEvent::Type arg2 ;
32397
32398   arg1 = (Dali::WheelEvent *)jarg1;
32399   arg2 = (Dali::WheelEvent::Type)jarg2;
32400   if (arg1) (arg1)->type = arg2;
32401 }
32402
32403
32404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32405   int jresult ;
32406   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32407   Dali::WheelEvent::Type result;
32408
32409   arg1 = (Dali::WheelEvent *)jarg1;
32410   result = (Dali::WheelEvent::Type) ((arg1)->type);
32411   jresult = (int)result;
32412   return jresult;
32413 }
32414
32415
32416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32417   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32418   int arg2 ;
32419
32420   arg1 = (Dali::WheelEvent *)jarg1;
32421   arg2 = (int)jarg2;
32422   if (arg1) (arg1)->direction = arg2;
32423 }
32424
32425
32426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32427   int jresult ;
32428   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32429   int result;
32430
32431   arg1 = (Dali::WheelEvent *)jarg1;
32432   result = (int) ((arg1)->direction);
32433   jresult = result;
32434   return jresult;
32435 }
32436
32437
32438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32439   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32440   unsigned int arg2 ;
32441
32442   arg1 = (Dali::WheelEvent *)jarg1;
32443   arg2 = (unsigned int)jarg2;
32444   if (arg1) (arg1)->modifiers = arg2;
32445 }
32446
32447
32448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32449   unsigned int jresult ;
32450   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32451   unsigned int result;
32452
32453   arg1 = (Dali::WheelEvent *)jarg1;
32454   result = (unsigned int) ((arg1)->modifiers);
32455   jresult = result;
32456   return jresult;
32457 }
32458
32459
32460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32461   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32462   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32463
32464   arg1 = (Dali::WheelEvent *)jarg1;
32465   arg2 = (Dali::Vector2 *)jarg2;
32466   if (arg1) (arg1)->point = *arg2;
32467 }
32468
32469
32470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32471   void * jresult ;
32472   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32473   Dali::Vector2 *result = 0 ;
32474
32475   arg1 = (Dali::WheelEvent *)jarg1;
32476   result = (Dali::Vector2 *)& ((arg1)->point);
32477   jresult = (void *)result;
32478   return jresult;
32479 }
32480
32481
32482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32483   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32484   int arg2 ;
32485
32486   arg1 = (Dali::WheelEvent *)jarg1;
32487   arg2 = (int)jarg2;
32488   if (arg1) (arg1)->z = arg2;
32489 }
32490
32491
32492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32493   int jresult ;
32494   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32495   int result;
32496
32497   arg1 = (Dali::WheelEvent *)jarg1;
32498   result = (int) ((arg1)->z);
32499   jresult = result;
32500   return jresult;
32501 }
32502
32503
32504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32505   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32506   unsigned int arg2 ;
32507
32508   arg1 = (Dali::WheelEvent *)jarg1;
32509   arg2 = (unsigned int)jarg2;
32510   if (arg1) (arg1)->timeStamp = arg2;
32511 }
32512
32513
32514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32515   unsigned int jresult ;
32516   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32517   unsigned int result;
32518
32519   arg1 = (Dali::WheelEvent *)jarg1;
32520   result = (unsigned int) ((arg1)->timeStamp);
32521   jresult = result;
32522   return jresult;
32523 }
32524
32525 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32526   char * jresult ;
32527   Dali::KeyEvent *arg1 = 0 ;
32528   std::string result;
32529
32530   arg1 = (Dali::KeyEvent *)jarg1;
32531   if (!arg1) {
32532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32533     return 0;
32534   }
32535   {
32536     try {
32537       result = arg1->GetDeviceName();
32538     } catch (std::out_of_range& e) {
32539       {
32540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32541       };
32542     } catch (std::exception& e) {
32543       {
32544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32545       };
32546     } catch (Dali::DaliException e) {
32547       {
32548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32549       };
32550     } catch (...) {
32551       {
32552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32553       };
32554     }
32555   }
32556
32557   jresult = SWIG_csharp_string_callback((&result)->c_str());
32558   return jresult;
32559 }
32560
32561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32562   int jresult ;
32563   Dali::KeyEvent *arg1 = 0 ;
32564   Dali::Device::Class::Type result;
32565
32566   arg1 = (Dali::KeyEvent *)jarg1;
32567   if (!arg1) {
32568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32569     return 0;
32570   }
32571   {
32572     try {
32573       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32574     } catch (std::out_of_range& e) {
32575       {
32576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32577       };
32578     } catch (std::exception& e) {
32579       {
32580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32581       };
32582     } catch (Dali::DaliException e) {
32583       {
32584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32585       };
32586     } catch (...) {
32587       {
32588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32589       };
32590     }
32591   }
32592
32593   jresult = (int)result;
32594   return jresult;
32595 }
32596
32597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32598   int jresult ;
32599   Dali::KeyEvent *arg1 = 0 ;
32600   Dali::Device::Subclass::Type result;
32601
32602   arg1 = (Dali::KeyEvent *)jarg1;
32603   if (!arg1) {
32604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32605     return 0;
32606   }
32607   {
32608     try {
32609       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32610     } catch (std::out_of_range& e) {
32611       {
32612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32613       };
32614     } catch (std::exception& e) {
32615       {
32616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32617       };
32618     } catch (Dali::DaliException e) {
32619       {
32620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32621       };
32622     } catch (...) {
32623       {
32624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32625       };
32626     }
32627   }
32628
32629   jresult = (int)result;
32630   return jresult;
32631 }
32632
32633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32634   Dali::Actor arg1 ;
32635   Dali::Actor *argp1 ;
32636
32637   argp1 = (Dali::Actor *)jarg1;
32638   if (!argp1) {
32639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32640     return ;
32641   }
32642   arg1 = *argp1;
32643   {
32644     try {
32645       arg1.Raise();
32646     } catch (std::out_of_range& e) {
32647       {
32648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32649       };
32650     } catch (std::exception& e) {
32651       {
32652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32653       };
32654     } catch (Dali::DaliException e) {
32655       {
32656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32657       };
32658     } catch (...) {
32659       {
32660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32661       };
32662     }
32663   }
32664
32665 }
32666
32667
32668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32669   Dali::Actor arg1 ;
32670   Dali::Actor *argp1 ;
32671
32672   argp1 = (Dali::Actor *)jarg1;
32673   if (!argp1) {
32674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32675     return ;
32676   }
32677   arg1 = *argp1;
32678   {
32679     try {
32680       arg1.Lower();
32681     } catch (std::out_of_range& e) {
32682       {
32683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32684       };
32685     } catch (std::exception& e) {
32686       {
32687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32688       };
32689     } catch (Dali::DaliException e) {
32690       {
32691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32692       };
32693     } catch (...) {
32694       {
32695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32696       };
32697     }
32698   }
32699
32700 }
32701
32702
32703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32704   Dali::Actor arg1 ;
32705   Dali::Actor *argp1 ;
32706
32707   argp1 = (Dali::Actor *)jarg1;
32708   if (!argp1) {
32709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32710     return ;
32711   }
32712   arg1 = *argp1;
32713   {
32714     try {
32715       arg1.RaiseToTop();
32716     } catch (std::out_of_range& e) {
32717       {
32718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32719       };
32720     } catch (std::exception& e) {
32721       {
32722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32723       };
32724     } catch (Dali::DaliException e) {
32725       {
32726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32727       };
32728     } catch (...) {
32729       {
32730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32731       };
32732     }
32733   }
32734
32735 }
32736
32737
32738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32739   Dali::Actor arg1 ;
32740   Dali::Actor *argp1 ;
32741
32742   argp1 = (Dali::Actor *)jarg1;
32743   if (!argp1) {
32744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32745     return ;
32746   }
32747   arg1 = *argp1;
32748   {
32749     try {
32750       arg1.LowerToBottom();
32751     } catch (std::out_of_range& e) {
32752       {
32753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32754       };
32755     } catch (std::exception& e) {
32756       {
32757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32758       };
32759     } catch (Dali::DaliException e) {
32760       {
32761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32762       };
32763     } catch (...) {
32764       {
32765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32766       };
32767     }
32768   }
32769
32770 }
32771
32772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32773   Dali::Actor arg1 ;
32774   Dali::Actor arg2 ;
32775   Dali::Actor *argp1 ;
32776   Dali::Actor *argp2 ;
32777
32778   argp1 = (Dali::Actor *)jarg1;
32779   if (!argp1) {
32780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32781     return ;
32782   }
32783   arg1 = *argp1;
32784   argp2 = (Dali::Actor *)jarg2;
32785   if (!argp2) {
32786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32787     return ;
32788   }
32789   arg2 = *argp2;
32790   {
32791     try {
32792       arg1.RaiseAbove(arg2);
32793     } catch (std::out_of_range& e) {
32794       {
32795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32796       };
32797     } catch (std::exception& e) {
32798       {
32799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32800       };
32801     } catch (Dali::DaliException e) {
32802       {
32803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32804       };
32805     } catch (...) {
32806       {
32807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32808       };
32809     }
32810   }
32811
32812 }
32813
32814
32815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32816   Dali::Actor arg1 ;
32817   Dali::Actor arg2 ;
32818   Dali::Actor *argp1 ;
32819   Dali::Actor *argp2 ;
32820
32821   argp1 = (Dali::Actor *)jarg1;
32822   if (!argp1) {
32823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32824     return ;
32825   }
32826   arg1 = *argp1;
32827   argp2 = (Dali::Actor *)jarg2;
32828   if (!argp2) {
32829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32830     return ;
32831   }
32832   arg2 = *argp2;
32833   {
32834     try {
32835       arg1.LowerBelow(arg2);
32836     } catch (std::out_of_range& e) {
32837       {
32838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32839       };
32840     } catch (std::exception& e) {
32841       {
32842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32843       };
32844     } catch (Dali::DaliException e) {
32845       {
32846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32847       };
32848     } catch (...) {
32849       {
32850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32851       };
32852     }
32853   }
32854
32855 }
32856
32857
32858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32859   void * jresult ;
32860   Dali::Actor arg1 ;
32861   Dali::Actor *argp1 ;
32862   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32863
32864   argp1 = (Dali::Actor *)jarg1;
32865   if (!argp1) {
32866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32867     return 0;
32868   }
32869   arg1 = *argp1;
32870   {
32871     try {
32872       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32873     } catch (std::out_of_range& e) {
32874       {
32875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32876       };
32877     } catch (std::exception& e) {
32878       {
32879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32880       };
32881     } catch (Dali::DaliException e) {
32882       {
32883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32884       };
32885     } catch (...) {
32886       {
32887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32888       };
32889     }
32890   }
32891
32892   jresult = (void *)result;
32893   return jresult;
32894 }
32895
32896
32897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32898   void * jresult ;
32899   Dali::Actor *arg1 ;
32900   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32901
32902   arg1 = (Dali::Actor *)jarg1;
32903   {
32904     try {
32905       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32906     } catch (std::out_of_range& e) {
32907       {
32908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32909       };
32910     } catch (std::exception& e) {
32911       {
32912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32913       };
32914     } catch (Dali::DaliException e) {
32915       {
32916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32917       };
32918     } catch (...) {
32919       {
32920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32921       };
32922     }
32923   }
32924
32925   jresult = (void *)result;
32926   return jresult;
32927 }
32928
32929
32930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32931   int jresult ;
32932   int result;
32933
32934   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32935   jresult = (int)result;
32936   return jresult;
32937 }
32938
32939
32940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32941   int jresult ;
32942   int result;
32943
32944   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32945   jresult = (int)result;
32946   return jresult;
32947 }
32948
32949
32950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32951   int jresult ;
32952   int result;
32953
32954   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32955   jresult = (int)result;
32956   return jresult;
32957 }
32958
32959
32960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32961   int jresult ;
32962   int result;
32963
32964   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32965   jresult = (int)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32971   int jresult ;
32972   int result;
32973
32974   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32975   jresult = (int)result;
32976   return jresult;
32977 }
32978
32979
32980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32981   int jresult ;
32982   int result;
32983
32984   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32985   jresult = (int)result;
32986   return jresult;
32987 }
32988
32989
32990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32991   int jresult ;
32992   int result;
32993
32994   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32995   jresult = (int)result;
32996   return jresult;
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33001   int jresult ;
33002   int result;
33003
33004   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33011   int jresult ;
33012   int result;
33013
33014   result = (int)Dali::Actor::Property::SIZE;
33015   jresult = (int)result;
33016   return jresult;
33017 }
33018
33019
33020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33021   int jresult ;
33022   int result;
33023
33024   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33025   jresult = (int)result;
33026   return jresult;
33027 }
33028
33029
33030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33031   int jresult ;
33032   int result;
33033
33034   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33035   jresult = (int)result;
33036   return jresult;
33037 }
33038
33039
33040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33041   int jresult ;
33042   int result;
33043
33044   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33045   jresult = (int)result;
33046   return jresult;
33047 }
33048
33049
33050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33051   int jresult ;
33052   int result;
33053
33054   result = (int)Dali::Actor::Property::POSITION;
33055   jresult = (int)result;
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33061   int jresult ;
33062   int result;
33063
33064   result = (int)Dali::Actor::Property::POSITION_X;
33065   jresult = (int)result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33071   int jresult ;
33072   int result;
33073
33074   result = (int)Dali::Actor::Property::POSITION_Y;
33075   jresult = (int)result;
33076   return jresult;
33077 }
33078
33079
33080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33081   int jresult ;
33082   int result;
33083
33084   result = (int)Dali::Actor::Property::POSITION_Z;
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33091   int jresult ;
33092   int result;
33093
33094   result = (int)Dali::Actor::Property::WORLD_POSITION;
33095   jresult = (int)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33101   int jresult ;
33102   int result;
33103
33104   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33111   int jresult ;
33112   int result;
33113
33114   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33115   jresult = (int)result;
33116   return jresult;
33117 }
33118
33119
33120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33121   int jresult ;
33122   int result;
33123
33124   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33125   jresult = (int)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::ORIENTATION;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::SCALE;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33161   int jresult ;
33162   int result;
33163
33164   result = (int)Dali::Actor::Property::SCALE_X;
33165   jresult = (int)result;
33166   return jresult;
33167 }
33168
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33171   int jresult ;
33172   int result;
33173
33174   result = (int)Dali::Actor::Property::SCALE_Y;
33175   jresult = (int)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33181   int jresult ;
33182   int result;
33183
33184   result = (int)Dali::Actor::Property::SCALE_Z;
33185   jresult = (int)result;
33186   return jresult;
33187 }
33188
33189
33190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33191   int jresult ;
33192   int result;
33193
33194   result = (int)Dali::Actor::Property::WORLD_SCALE;
33195   jresult = (int)result;
33196   return jresult;
33197 }
33198
33199
33200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33201   int jresult ;
33202   int result;
33203
33204   result = (int)Dali::Actor::Property::VISIBLE;
33205   jresult = (int)result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33211   int jresult ;
33212   int result;
33213
33214   result = (int)Dali::Actor::Property::COLOR;
33215   jresult = (int)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33221   int jresult ;
33222   int result;
33223
33224   result = (int)Dali::Actor::Property::COLOR_RED;
33225   jresult = (int)result;
33226   return jresult;
33227 }
33228
33229
33230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33231   int jresult ;
33232   int result;
33233
33234   result = (int)Dali::Actor::Property::COLOR_GREEN;
33235   jresult = (int)result;
33236   return jresult;
33237 }
33238
33239
33240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33241   int jresult ;
33242   int result;
33243
33244   result = (int)Dali::Actor::Property::COLOR_BLUE;
33245   jresult = (int)result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33251   int jresult ;
33252   int result;
33253
33254   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33255   jresult = (int)result;
33256   return jresult;
33257 }
33258
33259
33260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33261   int jresult ;
33262   int result;
33263
33264   result = (int)Dali::Actor::Property::WORLD_COLOR;
33265   jresult = (int)result;
33266   return jresult;
33267 }
33268
33269
33270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33271   int jresult ;
33272   int result;
33273
33274   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33275   jresult = (int)result;
33276   return jresult;
33277 }
33278
33279
33280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33281   int jresult ;
33282   int result;
33283
33284   result = (int)Dali::Actor::Property::NAME;
33285   jresult = (int)result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33291   int jresult ;
33292   int result;
33293
33294   result = (int)Dali::Actor::Property::SENSITIVE;
33295   jresult = (int)result;
33296   return jresult;
33297 }
33298
33299
33300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33301   int jresult ;
33302   int result;
33303
33304   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33305   jresult = (int)result;
33306   return jresult;
33307 }
33308
33309
33310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33311   int jresult ;
33312   int result;
33313
33314   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33315   jresult = (int)result;
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33321   int jresult ;
33322   int result;
33323
33324   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33325   jresult = (int)result;
33326   return jresult;
33327 }
33328
33329
33330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33331   int jresult ;
33332   int result;
33333
33334   result = (int)Dali::Actor::Property::COLOR_MODE;
33335   jresult = (int)result;
33336   return jresult;
33337 }
33338
33339
33340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33341   int jresult ;
33342   int result;
33343
33344   result = (int)Dali::Actor::Property::DRAW_MODE;
33345   jresult = (int)result;
33346   return jresult;
33347 }
33348
33349
33350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33351   int jresult ;
33352   int result;
33353
33354   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33355   jresult = (int)result;
33356   return jresult;
33357 }
33358
33359
33360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33361   int jresult ;
33362   int result;
33363
33364   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33365   jresult = (int)result;
33366   return jresult;
33367 }
33368
33369
33370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33371   int jresult ;
33372   int result;
33373
33374   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33375   jresult = (int)result;
33376   return jresult;
33377 }
33378
33379
33380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33381   int jresult ;
33382   int result;
33383
33384   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33385   jresult = (int)result;
33386   return jresult;
33387 }
33388
33389
33390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33391   int jresult ;
33392   int result;
33393
33394   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33395   jresult = (int)result;
33396   return jresult;
33397 }
33398
33399
33400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33401   int jresult ;
33402   int result;
33403
33404   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33405   jresult = (int)result;
33406   return jresult;
33407 }
33408
33409
33410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33411   int jresult ;
33412   int result;
33413
33414   result = (int)Dali::Actor::Property::PADDING;
33415   jresult = (int)result;
33416   return jresult;
33417 }
33418
33419
33420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33421   int jresult ;
33422   int result;
33423
33424   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33425   jresult = (int)result;
33426   return jresult;
33427 }
33428
33429
33430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33431   int jresult ;
33432   int result;
33433
33434   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33435   jresult = (int)result;
33436   return jresult;
33437 }
33438
33439
33440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33441   int jresult ;
33442   int result;
33443
33444   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33445   jresult = (int)result;
33446   return jresult;
33447 }
33448
33449
33450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33451   int jresult ;
33452   int result;
33453
33454   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33455   jresult = (int)result;
33456   return jresult;
33457 }
33458
33459
33460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33461   void * jresult ;
33462   Dali::Actor::Property *result = 0 ;
33463
33464   {
33465     try {
33466       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33467     } catch (std::out_of_range& e) {
33468       {
33469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33470       };
33471     } catch (std::exception& e) {
33472       {
33473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33474       };
33475     } catch (Dali::DaliException e) {
33476       {
33477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33478       };
33479     } catch (...) {
33480       {
33481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33482       };
33483     }
33484   }
33485
33486   jresult = (void *)result;
33487   return jresult;
33488 }
33489
33490
33491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33492   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33493
33494   arg1 = (Dali::Actor::Property *)jarg1;
33495   {
33496     try {
33497       delete arg1;
33498     } catch (std::out_of_range& e) {
33499       {
33500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33501       };
33502     } catch (std::exception& e) {
33503       {
33504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33505       };
33506     } catch (Dali::DaliException e) {
33507       {
33508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33509       };
33510     } catch (...) {
33511       {
33512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33513       };
33514     }
33515   }
33516
33517 }
33518
33519
33520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33521   void * jresult ;
33522   Dali::Actor *result = 0 ;
33523
33524   {
33525     try {
33526       result = (Dali::Actor *)new Dali::Actor();
33527     } catch (std::out_of_range& e) {
33528       {
33529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33530       };
33531     } catch (std::exception& e) {
33532       {
33533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33534       };
33535     } catch (Dali::DaliException e) {
33536       {
33537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33538       };
33539     } catch (...) {
33540       {
33541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33542       };
33543     }
33544   }
33545
33546   jresult = (void *)result;
33547   return jresult;
33548 }
33549
33550
33551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33552   void * jresult ;
33553   Dali::Actor result;
33554
33555   {
33556     try {
33557       result = Dali::Actor::New();
33558     } catch (std::out_of_range& e) {
33559       {
33560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33561       };
33562     } catch (std::exception& e) {
33563       {
33564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33565       };
33566     } catch (Dali::DaliException e) {
33567       {
33568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33569       };
33570     } catch (...) {
33571       {
33572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33573       };
33574     }
33575   }
33576
33577   jresult = new Dali::Actor((const Dali::Actor &)result);
33578   return jresult;
33579 }
33580
33581
33582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33583   void * jresult ;
33584   Dali::BaseHandle arg1 ;
33585   Dali::BaseHandle *argp1 ;
33586   Dali::Actor result;
33587
33588   argp1 = (Dali::BaseHandle *)jarg1;
33589   if (!argp1) {
33590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33591     return 0;
33592   }
33593   arg1 = *argp1;
33594   {
33595     try {
33596       result = Dali::Actor::DownCast(arg1);
33597     } catch (std::out_of_range& e) {
33598       {
33599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33600       };
33601     } catch (std::exception& e) {
33602       {
33603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33604       };
33605     } catch (Dali::DaliException e) {
33606       {
33607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33608       };
33609     } catch (...) {
33610       {
33611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33612       };
33613     }
33614   }
33615
33616   jresult = new Dali::Actor((const Dali::Actor &)result);
33617   return jresult;
33618 }
33619
33620
33621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33623
33624   arg1 = (Dali::Actor *)jarg1;
33625   {
33626     try {
33627       delete arg1;
33628     } catch (std::out_of_range& e) {
33629       {
33630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33631       };
33632     } catch (std::exception& e) {
33633       {
33634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33635       };
33636     } catch (Dali::DaliException e) {
33637       {
33638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33639       };
33640     } catch (...) {
33641       {
33642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33643       };
33644     }
33645   }
33646
33647 }
33648
33649
33650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33651   void * jresult ;
33652   Dali::Actor *arg1 = 0 ;
33653   Dali::Actor *result = 0 ;
33654
33655   arg1 = (Dali::Actor *)jarg1;
33656   if (!arg1) {
33657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33658     return 0;
33659   }
33660   {
33661     try {
33662       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33663     } catch (std::out_of_range& e) {
33664       {
33665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33666       };
33667     } catch (std::exception& e) {
33668       {
33669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33670       };
33671     } catch (Dali::DaliException e) {
33672       {
33673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33674       };
33675     } catch (...) {
33676       {
33677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33678       };
33679     }
33680   }
33681
33682   jresult = (void *)result;
33683   return jresult;
33684 }
33685
33686
33687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33688   void * jresult ;
33689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33690   Dali::Actor *arg2 = 0 ;
33691   Dali::Actor *result = 0 ;
33692
33693   arg1 = (Dali::Actor *)jarg1;
33694   arg2 = (Dali::Actor *)jarg2;
33695   if (!arg2) {
33696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33697     return 0;
33698   }
33699   {
33700     try {
33701       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33702     } catch (std::out_of_range& e) {
33703       {
33704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33705       };
33706     } catch (std::exception& e) {
33707       {
33708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33709       };
33710     } catch (Dali::DaliException e) {
33711       {
33712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33713       };
33714     } catch (...) {
33715       {
33716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33717       };
33718     }
33719   }
33720
33721   jresult = (void *)result;
33722   return jresult;
33723 }
33724
33725
33726 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33727   char * jresult ;
33728   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33729   std::string *result = 0 ;
33730
33731   arg1 = (Dali::Actor *)jarg1;
33732   {
33733     try {
33734       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33735     } catch (std::out_of_range& e) {
33736       {
33737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33738       };
33739     } catch (std::exception& e) {
33740       {
33741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33742       };
33743     } catch (Dali::DaliException e) {
33744       {
33745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33746       };
33747     } catch (...) {
33748       {
33749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33750       };
33751     }
33752   }
33753
33754   jresult = SWIG_csharp_string_callback(result->c_str());
33755   return jresult;
33756 }
33757
33758
33759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33761   std::string *arg2 = 0 ;
33762
33763   arg1 = (Dali::Actor *)jarg1;
33764   if (!jarg2) {
33765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33766     return ;
33767   }
33768   std::string arg2_str(jarg2);
33769   arg2 = &arg2_str;
33770   {
33771     try {
33772       (arg1)->SetName((std::string const &)*arg2);
33773     } catch (std::out_of_range& e) {
33774       {
33775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33776       };
33777     } catch (std::exception& e) {
33778       {
33779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33780       };
33781     } catch (Dali::DaliException e) {
33782       {
33783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33784       };
33785     } catch (...) {
33786       {
33787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33788       };
33789     }
33790   }
33791
33792
33793   //argout typemap for const std::string&
33794
33795 }
33796
33797
33798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33799   unsigned int jresult ;
33800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33801   unsigned int result;
33802
33803   arg1 = (Dali::Actor *)jarg1;
33804   {
33805     try {
33806       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33807     } catch (std::out_of_range& e) {
33808       {
33809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33810       };
33811     } catch (std::exception& e) {
33812       {
33813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33814       };
33815     } catch (Dali::DaliException e) {
33816       {
33817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33818       };
33819     } catch (...) {
33820       {
33821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33822       };
33823     }
33824   }
33825
33826   jresult = result;
33827   return jresult;
33828 }
33829
33830
33831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33832   unsigned int jresult ;
33833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33834   bool result;
33835
33836   arg1 = (Dali::Actor *)jarg1;
33837   {
33838     try {
33839       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33840     } catch (std::out_of_range& e) {
33841       {
33842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33843       };
33844     } catch (std::exception& e) {
33845       {
33846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33847       };
33848     } catch (Dali::DaliException e) {
33849       {
33850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33851       };
33852     } catch (...) {
33853       {
33854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33855       };
33856     }
33857   }
33858
33859   jresult = result;
33860   return jresult;
33861 }
33862
33863
33864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33865   unsigned int jresult ;
33866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33867   bool result;
33868
33869   arg1 = (Dali::Actor *)jarg1;
33870   {
33871     try {
33872       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33873     } catch (std::out_of_range& e) {
33874       {
33875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33876       };
33877     } catch (std::exception& e) {
33878       {
33879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33880       };
33881     } catch (Dali::DaliException e) {
33882       {
33883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33884       };
33885     } catch (...) {
33886       {
33887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33888       };
33889     }
33890   }
33891
33892   jresult = result;
33893   return jresult;
33894 }
33895
33896
33897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33898   unsigned int jresult ;
33899   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33900   bool result;
33901
33902   arg1 = (Dali::Actor *)jarg1;
33903   {
33904     try {
33905       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33906     } catch (std::out_of_range& e) {
33907       {
33908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33909       };
33910     } catch (std::exception& e) {
33911       {
33912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33913       };
33914     } catch (Dali::DaliException e) {
33915       {
33916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33917       };
33918     } catch (...) {
33919       {
33920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33921       };
33922     }
33923   }
33924
33925   jresult = result;
33926   return jresult;
33927 }
33928
33929
33930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33931   void * jresult ;
33932   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33933   Dali::Layer result;
33934
33935   arg1 = (Dali::Actor *)jarg1;
33936   {
33937     try {
33938       result = (arg1)->GetLayer();
33939     } catch (std::out_of_range& e) {
33940       {
33941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33942       };
33943     } catch (std::exception& e) {
33944       {
33945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33946       };
33947     } catch (Dali::DaliException e) {
33948       {
33949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33950       };
33951     } catch (...) {
33952       {
33953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33954       };
33955     }
33956   }
33957
33958   jresult = new Dali::Layer((const Dali::Layer &)result);
33959   return jresult;
33960 }
33961
33962
33963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33965   Dali::Actor arg2 ;
33966   Dali::Actor *argp2 ;
33967
33968   arg1 = (Dali::Actor *)jarg1;
33969   argp2 = (Dali::Actor *)jarg2;
33970   if (!argp2) {
33971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33972     return ;
33973   }
33974   arg2 = *argp2;
33975   {
33976     try {
33977       (arg1)->Add(arg2);
33978     } catch (std::out_of_range& e) {
33979       {
33980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33981       };
33982     } catch (std::exception& e) {
33983       {
33984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33985       };
33986     } catch (Dali::DaliException e) {
33987       {
33988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33989       };
33990     } catch (...) {
33991       {
33992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33993       };
33994     }
33995   }
33996
33997 }
33998
33999
34000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34002   Dali::Actor arg2 ;
34003   Dali::Actor *argp2 ;
34004
34005   arg1 = (Dali::Actor *)jarg1;
34006   argp2 = (Dali::Actor *)jarg2;
34007   if (!argp2) {
34008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34009     return ;
34010   }
34011   arg2 = *argp2;
34012   {
34013     try {
34014       (arg1)->Remove(arg2);
34015     } catch (std::out_of_range& e) {
34016       {
34017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34018       };
34019     } catch (std::exception& e) {
34020       {
34021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34022       };
34023     } catch (Dali::DaliException e) {
34024       {
34025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34026       };
34027     } catch (...) {
34028       {
34029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34030       };
34031     }
34032   }
34033
34034 }
34035
34036
34037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34038   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34039
34040   arg1 = (Dali::Actor *)jarg1;
34041   {
34042     try {
34043       (arg1)->Unparent();
34044     } catch (std::out_of_range& e) {
34045       {
34046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34047       };
34048     } catch (std::exception& e) {
34049       {
34050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34051       };
34052     } catch (Dali::DaliException e) {
34053       {
34054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34055       };
34056     } catch (...) {
34057       {
34058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34059       };
34060     }
34061   }
34062
34063 }
34064
34065
34066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34067   unsigned int jresult ;
34068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34069   unsigned int result;
34070
34071   arg1 = (Dali::Actor *)jarg1;
34072   {
34073     try {
34074       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34075     } catch (std::out_of_range& e) {
34076       {
34077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34078       };
34079     } catch (std::exception& e) {
34080       {
34081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34082       };
34083     } catch (Dali::DaliException e) {
34084       {
34085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34086       };
34087     } catch (...) {
34088       {
34089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34090       };
34091     }
34092   }
34093
34094   jresult = result;
34095   return jresult;
34096 }
34097
34098
34099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34100   void * jresult ;
34101   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34102   unsigned int arg2 ;
34103   Dali::Actor result;
34104
34105   arg1 = (Dali::Actor *)jarg1;
34106   arg2 = (unsigned int)jarg2;
34107   {
34108     try {
34109       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34110     } catch (std::out_of_range& e) {
34111       {
34112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34113       };
34114     } catch (std::exception& e) {
34115       {
34116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34117       };
34118     } catch (Dali::DaliException e) {
34119       {
34120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34121       };
34122     } catch (...) {
34123       {
34124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34125       };
34126     }
34127   }
34128
34129   jresult = new Dali::Actor((const Dali::Actor &)result);
34130   return jresult;
34131 }
34132
34133
34134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34135   void * jresult ;
34136   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34137   std::string *arg2 = 0 ;
34138   Dali::Actor result;
34139
34140   arg1 = (Dali::Actor *)jarg1;
34141   if (!jarg2) {
34142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34143     return 0;
34144   }
34145   std::string arg2_str(jarg2);
34146   arg2 = &arg2_str;
34147   {
34148     try {
34149       result = (arg1)->FindChildByName((std::string const &)*arg2);
34150     } catch (std::out_of_range& e) {
34151       {
34152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34153       };
34154     } catch (std::exception& e) {
34155       {
34156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34157       };
34158     } catch (Dali::DaliException e) {
34159       {
34160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34161       };
34162     } catch (...) {
34163       {
34164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34165       };
34166     }
34167   }
34168
34169   jresult = new Dali::Actor((const Dali::Actor &)result);
34170
34171   //argout typemap for const std::string&
34172
34173   return jresult;
34174 }
34175
34176
34177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34178   void * jresult ;
34179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34180   unsigned int arg2 ;
34181   Dali::Actor result;
34182
34183   arg1 = (Dali::Actor *)jarg1;
34184   arg2 = (unsigned int)jarg2;
34185   {
34186     try {
34187       result = (arg1)->FindChildById(arg2);
34188     } catch (std::out_of_range& e) {
34189       {
34190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34191       };
34192     } catch (std::exception& e) {
34193       {
34194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34195       };
34196     } catch (Dali::DaliException e) {
34197       {
34198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34199       };
34200     } catch (...) {
34201       {
34202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34203       };
34204     }
34205   }
34206
34207   jresult = new Dali::Actor((const Dali::Actor &)result);
34208   return jresult;
34209 }
34210
34211
34212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34213   void * jresult ;
34214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34215   Dali::Actor result;
34216
34217   arg1 = (Dali::Actor *)jarg1;
34218   {
34219     try {
34220       result = ((Dali::Actor const *)arg1)->GetParent();
34221     } catch (std::out_of_range& e) {
34222       {
34223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34224       };
34225     } catch (std::exception& e) {
34226       {
34227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34228       };
34229     } catch (Dali::DaliException e) {
34230       {
34231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34232       };
34233     } catch (...) {
34234       {
34235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34236       };
34237     }
34238   }
34239
34240   jresult = new Dali::Actor((const Dali::Actor &)result);
34241   return jresult;
34242 }
34243
34244
34245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34246   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34247   Dali::Vector3 *arg2 = 0 ;
34248
34249   arg1 = (Dali::Actor *)jarg1;
34250   arg2 = (Dali::Vector3 *)jarg2;
34251   if (!arg2) {
34252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34253     return ;
34254   }
34255   {
34256     try {
34257       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34258     } catch (std::out_of_range& e) {
34259       {
34260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34261       };
34262     } catch (std::exception& e) {
34263       {
34264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34265       };
34266     } catch (Dali::DaliException e) {
34267       {
34268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34269       };
34270     } catch (...) {
34271       {
34272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34273       };
34274     }
34275   }
34276
34277 }
34278
34279
34280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34281   void * jresult ;
34282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34283   Dali::Vector3 result;
34284
34285   arg1 = (Dali::Actor *)jarg1;
34286   {
34287     try {
34288       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34289     } catch (std::out_of_range& e) {
34290       {
34291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34292       };
34293     } catch (std::exception& e) {
34294       {
34295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34296       };
34297     } catch (Dali::DaliException e) {
34298       {
34299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34300       };
34301     } catch (...) {
34302       {
34303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34304       };
34305     }
34306   }
34307
34308   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34309   return jresult;
34310 }
34311
34312
34313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34314   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34315   Dali::Vector3 *arg2 = 0 ;
34316
34317   arg1 = (Dali::Actor *)jarg1;
34318   arg2 = (Dali::Vector3 *)jarg2;
34319   if (!arg2) {
34320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34321     return ;
34322   }
34323   {
34324     try {
34325       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34326     } catch (std::out_of_range& e) {
34327       {
34328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34329       };
34330     } catch (std::exception& e) {
34331       {
34332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34333       };
34334     } catch (Dali::DaliException e) {
34335       {
34336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34337       };
34338     } catch (...) {
34339       {
34340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34341       };
34342     }
34343   }
34344
34345 }
34346
34347
34348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34349   void * jresult ;
34350   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34351   Dali::Vector3 result;
34352
34353   arg1 = (Dali::Actor *)jarg1;
34354   {
34355     try {
34356       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34357     } catch (std::out_of_range& e) {
34358       {
34359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34360       };
34361     } catch (std::exception& e) {
34362       {
34363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34364       };
34365     } catch (Dali::DaliException e) {
34366       {
34367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34368       };
34369     } catch (...) {
34370       {
34371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34372       };
34373     }
34374   }
34375
34376   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34377   return jresult;
34378 }
34379
34380
34381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34383   float arg2 ;
34384   float arg3 ;
34385
34386   arg1 = (Dali::Actor *)jarg1;
34387   arg2 = (float)jarg2;
34388   arg3 = (float)jarg3;
34389   {
34390     try {
34391       (arg1)->SetSize(arg2,arg3);
34392     } catch (std::out_of_range& e) {
34393       {
34394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34395       };
34396     } catch (std::exception& e) {
34397       {
34398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34399       };
34400     } catch (Dali::DaliException e) {
34401       {
34402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34403       };
34404     } catch (...) {
34405       {
34406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34407       };
34408     }
34409   }
34410
34411 }
34412
34413
34414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34416   float arg2 ;
34417   float arg3 ;
34418   float arg4 ;
34419
34420   arg1 = (Dali::Actor *)jarg1;
34421   arg2 = (float)jarg2;
34422   arg3 = (float)jarg3;
34423   arg4 = (float)jarg4;
34424   {
34425     try {
34426       (arg1)->SetSize(arg2,arg3,arg4);
34427     } catch (std::out_of_range& e) {
34428       {
34429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34430       };
34431     } catch (std::exception& e) {
34432       {
34433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34434       };
34435     } catch (Dali::DaliException e) {
34436       {
34437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34438       };
34439     } catch (...) {
34440       {
34441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34442       };
34443     }
34444   }
34445
34446 }
34447
34448
34449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34450   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34451   Dali::Vector2 *arg2 = 0 ;
34452
34453   arg1 = (Dali::Actor *)jarg1;
34454   arg2 = (Dali::Vector2 *)jarg2;
34455   if (!arg2) {
34456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34457     return ;
34458   }
34459   {
34460     try {
34461       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34462     } catch (std::out_of_range& e) {
34463       {
34464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34465       };
34466     } catch (std::exception& e) {
34467       {
34468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34469       };
34470     } catch (Dali::DaliException e) {
34471       {
34472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34473       };
34474     } catch (...) {
34475       {
34476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34477       };
34478     }
34479   }
34480
34481 }
34482
34483
34484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34485   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34486   Dali::Vector3 *arg2 = 0 ;
34487
34488   arg1 = (Dali::Actor *)jarg1;
34489   arg2 = (Dali::Vector3 *)jarg2;
34490   if (!arg2) {
34491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34492     return ;
34493   }
34494   {
34495     try {
34496       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34497     } catch (std::out_of_range& e) {
34498       {
34499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34500       };
34501     } catch (std::exception& e) {
34502       {
34503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34504       };
34505     } catch (Dali::DaliException e) {
34506       {
34507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34508       };
34509     } catch (...) {
34510       {
34511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34512       };
34513     }
34514   }
34515
34516 }
34517
34518
34519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34520   void * jresult ;
34521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34522   Dali::Vector3 result;
34523
34524   arg1 = (Dali::Actor *)jarg1;
34525   {
34526     try {
34527       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34528     } catch (std::out_of_range& e) {
34529       {
34530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34531       };
34532     } catch (std::exception& e) {
34533       {
34534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34535       };
34536     } catch (Dali::DaliException e) {
34537       {
34538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34539       };
34540     } catch (...) {
34541       {
34542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34543       };
34544     }
34545   }
34546
34547   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34548   return jresult;
34549 }
34550
34551
34552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34553   void * jresult ;
34554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34555   Dali::Vector3 result;
34556
34557   arg1 = (Dali::Actor *)jarg1;
34558   {
34559     try {
34560       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34561     } catch (std::out_of_range& e) {
34562       {
34563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34564       };
34565     } catch (std::exception& e) {
34566       {
34567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34568       };
34569     } catch (Dali::DaliException e) {
34570       {
34571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34572       };
34573     } catch (...) {
34574       {
34575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34576       };
34577     }
34578   }
34579
34580   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34581   return jresult;
34582 }
34583
34584
34585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34586   void * jresult ;
34587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34588   Dali::Vector3 result;
34589
34590   arg1 = (Dali::Actor *)jarg1;
34591   {
34592     try {
34593       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34594     } catch (std::out_of_range& e) {
34595       {
34596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34597       };
34598     } catch (std::exception& e) {
34599       {
34600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34601       };
34602     } catch (Dali::DaliException e) {
34603       {
34604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34605       };
34606     } catch (...) {
34607       {
34608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34609       };
34610     }
34611   }
34612
34613   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34614   return jresult;
34615 }
34616
34617
34618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34619   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34620   float arg2 ;
34621   float arg3 ;
34622
34623   arg1 = (Dali::Actor *)jarg1;
34624   arg2 = (float)jarg2;
34625   arg3 = (float)jarg3;
34626   {
34627     try {
34628       (arg1)->SetPosition(arg2,arg3);
34629     } catch (std::out_of_range& e) {
34630       {
34631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34632       };
34633     } catch (std::exception& e) {
34634       {
34635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34636       };
34637     } catch (Dali::DaliException e) {
34638       {
34639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34640       };
34641     } catch (...) {
34642       {
34643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34644       };
34645     }
34646   }
34647
34648 }
34649
34650
34651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34653   float arg2 ;
34654   float arg3 ;
34655   float arg4 ;
34656
34657   arg1 = (Dali::Actor *)jarg1;
34658   arg2 = (float)jarg2;
34659   arg3 = (float)jarg3;
34660   arg4 = (float)jarg4;
34661   {
34662     try {
34663       (arg1)->SetPosition(arg2,arg3,arg4);
34664     } catch (std::out_of_range& e) {
34665       {
34666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34667       };
34668     } catch (std::exception& e) {
34669       {
34670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34671       };
34672     } catch (Dali::DaliException e) {
34673       {
34674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34675       };
34676     } catch (...) {
34677       {
34678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34679       };
34680     }
34681   }
34682
34683 }
34684
34685
34686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34688   Dali::Vector3 *arg2 = 0 ;
34689
34690   arg1 = (Dali::Actor *)jarg1;
34691   arg2 = (Dali::Vector3 *)jarg2;
34692   if (!arg2) {
34693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34694     return ;
34695   }
34696   {
34697     try {
34698       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34699     } catch (std::out_of_range& e) {
34700       {
34701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34702       };
34703     } catch (std::exception& e) {
34704       {
34705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34706       };
34707     } catch (Dali::DaliException e) {
34708       {
34709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34710       };
34711     } catch (...) {
34712       {
34713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34714       };
34715     }
34716   }
34717
34718 }
34719
34720
34721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34723   float arg2 ;
34724
34725   arg1 = (Dali::Actor *)jarg1;
34726   arg2 = (float)jarg2;
34727   {
34728     try {
34729       (arg1)->SetX(arg2);
34730     } catch (std::out_of_range& e) {
34731       {
34732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34733       };
34734     } catch (std::exception& e) {
34735       {
34736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34737       };
34738     } catch (Dali::DaliException e) {
34739       {
34740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34741       };
34742     } catch (...) {
34743       {
34744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34745       };
34746     }
34747   }
34748
34749 }
34750
34751
34752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34754   float arg2 ;
34755
34756   arg1 = (Dali::Actor *)jarg1;
34757   arg2 = (float)jarg2;
34758   {
34759     try {
34760       (arg1)->SetY(arg2);
34761     } catch (std::out_of_range& e) {
34762       {
34763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34764       };
34765     } catch (std::exception& e) {
34766       {
34767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34768       };
34769     } catch (Dali::DaliException e) {
34770       {
34771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34772       };
34773     } catch (...) {
34774       {
34775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34776       };
34777     }
34778   }
34779
34780 }
34781
34782
34783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34784   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34785   float arg2 ;
34786
34787   arg1 = (Dali::Actor *)jarg1;
34788   arg2 = (float)jarg2;
34789   {
34790     try {
34791       (arg1)->SetZ(arg2);
34792     } catch (std::out_of_range& e) {
34793       {
34794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34795       };
34796     } catch (std::exception& e) {
34797       {
34798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34799       };
34800     } catch (Dali::DaliException e) {
34801       {
34802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34803       };
34804     } catch (...) {
34805       {
34806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34807       };
34808     }
34809   }
34810
34811 }
34812
34813
34814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34816   Dali::Vector3 *arg2 = 0 ;
34817
34818   arg1 = (Dali::Actor *)jarg1;
34819   arg2 = (Dali::Vector3 *)jarg2;
34820   if (!arg2) {
34821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34822     return ;
34823   }
34824   {
34825     try {
34826       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34827     } catch (std::out_of_range& e) {
34828       {
34829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34830       };
34831     } catch (std::exception& e) {
34832       {
34833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34834       };
34835     } catch (Dali::DaliException e) {
34836       {
34837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34838       };
34839     } catch (...) {
34840       {
34841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34842       };
34843     }
34844   }
34845
34846 }
34847
34848
34849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34850   void * jresult ;
34851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34852   Dali::Vector3 result;
34853
34854   arg1 = (Dali::Actor *)jarg1;
34855   {
34856     try {
34857       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34858     } catch (std::out_of_range& e) {
34859       {
34860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34861       };
34862     } catch (std::exception& e) {
34863       {
34864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34865       };
34866     } catch (Dali::DaliException e) {
34867       {
34868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34869       };
34870     } catch (...) {
34871       {
34872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34873       };
34874     }
34875   }
34876
34877   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34878   return jresult;
34879 }
34880
34881
34882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34883   void * jresult ;
34884   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34885   Dali::Vector3 result;
34886
34887   arg1 = (Dali::Actor *)jarg1;
34888   {
34889     try {
34890       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34891     } catch (std::out_of_range& e) {
34892       {
34893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34894       };
34895     } catch (std::exception& e) {
34896       {
34897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34898       };
34899     } catch (Dali::DaliException e) {
34900       {
34901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34902       };
34903     } catch (...) {
34904       {
34905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34906       };
34907     }
34908   }
34909
34910   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34911   return jresult;
34912 }
34913
34914
34915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34917   bool arg2 ;
34918
34919   arg1 = (Dali::Actor *)jarg1;
34920   arg2 = jarg2 ? true : false;
34921   {
34922     try {
34923       (arg1)->SetInheritPosition(arg2);
34924     } catch (std::out_of_range& e) {
34925       {
34926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34927       };
34928     } catch (std::exception& e) {
34929       {
34930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34931       };
34932     } catch (Dali::DaliException e) {
34933       {
34934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34935       };
34936     } catch (...) {
34937       {
34938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34939       };
34940     }
34941   }
34942
34943 }
34944
34945
34946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34947   unsigned int jresult ;
34948   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34949   bool result;
34950
34951   arg1 = (Dali::Actor *)jarg1;
34952   {
34953     try {
34954       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34955     } catch (std::out_of_range& e) {
34956       {
34957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34958       };
34959     } catch (std::exception& e) {
34960       {
34961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34962       };
34963     } catch (Dali::DaliException e) {
34964       {
34965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34966       };
34967     } catch (...) {
34968       {
34969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34970       };
34971     }
34972   }
34973
34974   jresult = result;
34975   return jresult;
34976 }
34977
34978
34979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34980   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34981   Dali::Degree *arg2 = 0 ;
34982   Dali::Vector3 *arg3 = 0 ;
34983
34984   arg1 = (Dali::Actor *)jarg1;
34985   arg2 = (Dali::Degree *)jarg2;
34986   if (!arg2) {
34987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34988     return ;
34989   }
34990   arg3 = (Dali::Vector3 *)jarg3;
34991   if (!arg3) {
34992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34993     return ;
34994   }
34995   {
34996     try {
34997       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34998     } catch (std::out_of_range& e) {
34999       {
35000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35001       };
35002     } catch (std::exception& e) {
35003       {
35004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35005       };
35006     } catch (Dali::DaliException e) {
35007       {
35008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35009       };
35010     } catch (...) {
35011       {
35012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35013       };
35014     }
35015   }
35016
35017 }
35018
35019
35020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35021   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35022   Dali::Radian *arg2 = 0 ;
35023   Dali::Vector3 *arg3 = 0 ;
35024
35025   arg1 = (Dali::Actor *)jarg1;
35026   arg2 = (Dali::Radian *)jarg2;
35027   if (!arg2) {
35028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35029     return ;
35030   }
35031   arg3 = (Dali::Vector3 *)jarg3;
35032   if (!arg3) {
35033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35034     return ;
35035   }
35036   {
35037     try {
35038       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35039     } catch (std::out_of_range& e) {
35040       {
35041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35042       };
35043     } catch (std::exception& e) {
35044       {
35045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35046       };
35047     } catch (Dali::DaliException e) {
35048       {
35049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35050       };
35051     } catch (...) {
35052       {
35053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35054       };
35055     }
35056   }
35057
35058 }
35059
35060
35061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35062   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35063   Dali::Quaternion *arg2 = 0 ;
35064
35065   arg1 = (Dali::Actor *)jarg1;
35066   arg2 = (Dali::Quaternion *)jarg2;
35067   if (!arg2) {
35068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35069     return ;
35070   }
35071   {
35072     try {
35073       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35074     } catch (std::out_of_range& e) {
35075       {
35076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35077       };
35078     } catch (std::exception& e) {
35079       {
35080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35081       };
35082     } catch (Dali::DaliException e) {
35083       {
35084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35085       };
35086     } catch (...) {
35087       {
35088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35089       };
35090     }
35091   }
35092
35093 }
35094
35095
35096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35097   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35098   Dali::Degree *arg2 = 0 ;
35099   Dali::Vector3 *arg3 = 0 ;
35100
35101   arg1 = (Dali::Actor *)jarg1;
35102   arg2 = (Dali::Degree *)jarg2;
35103   if (!arg2) {
35104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35105     return ;
35106   }
35107   arg3 = (Dali::Vector3 *)jarg3;
35108   if (!arg3) {
35109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35110     return ;
35111   }
35112   {
35113     try {
35114       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35115     } catch (std::out_of_range& e) {
35116       {
35117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35118       };
35119     } catch (std::exception& e) {
35120       {
35121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35122       };
35123     } catch (Dali::DaliException e) {
35124       {
35125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35126       };
35127     } catch (...) {
35128       {
35129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35130       };
35131     }
35132   }
35133
35134 }
35135
35136
35137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35139   Dali::Radian *arg2 = 0 ;
35140   Dali::Vector3 *arg3 = 0 ;
35141
35142   arg1 = (Dali::Actor *)jarg1;
35143   arg2 = (Dali::Radian *)jarg2;
35144   if (!arg2) {
35145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35146     return ;
35147   }
35148   arg3 = (Dali::Vector3 *)jarg3;
35149   if (!arg3) {
35150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35151     return ;
35152   }
35153   {
35154     try {
35155       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35156     } catch (std::out_of_range& e) {
35157       {
35158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35159       };
35160     } catch (std::exception& e) {
35161       {
35162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35163       };
35164     } catch (Dali::DaliException e) {
35165       {
35166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35167       };
35168     } catch (...) {
35169       {
35170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35171       };
35172     }
35173   }
35174
35175 }
35176
35177
35178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35180   Dali::Quaternion *arg2 = 0 ;
35181
35182   arg1 = (Dali::Actor *)jarg1;
35183   arg2 = (Dali::Quaternion *)jarg2;
35184   if (!arg2) {
35185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35186     return ;
35187   }
35188   {
35189     try {
35190       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35191     } catch (std::out_of_range& e) {
35192       {
35193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35194       };
35195     } catch (std::exception& e) {
35196       {
35197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35198       };
35199     } catch (Dali::DaliException e) {
35200       {
35201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35202       };
35203     } catch (...) {
35204       {
35205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35206       };
35207     }
35208   }
35209
35210 }
35211
35212
35213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35214   void * jresult ;
35215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35216   Dali::Quaternion result;
35217
35218   arg1 = (Dali::Actor *)jarg1;
35219   {
35220     try {
35221       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35222     } catch (std::out_of_range& e) {
35223       {
35224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35225       };
35226     } catch (std::exception& e) {
35227       {
35228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35229       };
35230     } catch (Dali::DaliException e) {
35231       {
35232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35233       };
35234     } catch (...) {
35235       {
35236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35237       };
35238     }
35239   }
35240
35241   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35242   return jresult;
35243 }
35244
35245
35246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35247   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35248   bool arg2 ;
35249
35250   arg1 = (Dali::Actor *)jarg1;
35251   arg2 = jarg2 ? true : false;
35252   {
35253     try {
35254       (arg1)->SetInheritOrientation(arg2);
35255     } catch (std::out_of_range& e) {
35256       {
35257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35258       };
35259     } catch (std::exception& e) {
35260       {
35261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35262       };
35263     } catch (Dali::DaliException e) {
35264       {
35265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35266       };
35267     } catch (...) {
35268       {
35269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35270       };
35271     }
35272   }
35273
35274 }
35275
35276
35277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35278   unsigned int jresult ;
35279   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35280   bool result;
35281
35282   arg1 = (Dali::Actor *)jarg1;
35283   {
35284     try {
35285       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35286     } catch (std::out_of_range& e) {
35287       {
35288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35289       };
35290     } catch (std::exception& e) {
35291       {
35292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35293       };
35294     } catch (Dali::DaliException e) {
35295       {
35296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35297       };
35298     } catch (...) {
35299       {
35300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35301       };
35302     }
35303   }
35304
35305   jresult = result;
35306   return jresult;
35307 }
35308
35309
35310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35311   void * jresult ;
35312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35313   Dali::Quaternion result;
35314
35315   arg1 = (Dali::Actor *)jarg1;
35316   {
35317     try {
35318       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35319     } catch (std::out_of_range& e) {
35320       {
35321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35322       };
35323     } catch (std::exception& e) {
35324       {
35325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35326       };
35327     } catch (Dali::DaliException e) {
35328       {
35329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35330       };
35331     } catch (...) {
35332       {
35333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35334       };
35335     }
35336   }
35337
35338   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35339   return jresult;
35340 }
35341
35342
35343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35345   float arg2 ;
35346
35347   arg1 = (Dali::Actor *)jarg1;
35348   arg2 = (float)jarg2;
35349   {
35350     try {
35351       (arg1)->SetScale(arg2);
35352     } catch (std::out_of_range& e) {
35353       {
35354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35355       };
35356     } catch (std::exception& e) {
35357       {
35358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35359       };
35360     } catch (Dali::DaliException e) {
35361       {
35362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35363       };
35364     } catch (...) {
35365       {
35366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35367       };
35368     }
35369   }
35370
35371 }
35372
35373
35374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35375   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35376   float arg2 ;
35377   float arg3 ;
35378   float arg4 ;
35379
35380   arg1 = (Dali::Actor *)jarg1;
35381   arg2 = (float)jarg2;
35382   arg3 = (float)jarg3;
35383   arg4 = (float)jarg4;
35384   {
35385     try {
35386       (arg1)->SetScale(arg2,arg3,arg4);
35387     } catch (std::out_of_range& e) {
35388       {
35389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35390       };
35391     } catch (std::exception& e) {
35392       {
35393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35394       };
35395     } catch (Dali::DaliException e) {
35396       {
35397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35398       };
35399     } catch (...) {
35400       {
35401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35402       };
35403     }
35404   }
35405
35406 }
35407
35408
35409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35410   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35411   Dali::Vector3 *arg2 = 0 ;
35412
35413   arg1 = (Dali::Actor *)jarg1;
35414   arg2 = (Dali::Vector3 *)jarg2;
35415   if (!arg2) {
35416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35417     return ;
35418   }
35419   {
35420     try {
35421       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35422     } catch (std::out_of_range& e) {
35423       {
35424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35425       };
35426     } catch (std::exception& e) {
35427       {
35428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35429       };
35430     } catch (Dali::DaliException e) {
35431       {
35432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35433       };
35434     } catch (...) {
35435       {
35436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35437       };
35438     }
35439   }
35440
35441 }
35442
35443
35444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35445   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35446   Dali::Vector3 *arg2 = 0 ;
35447
35448   arg1 = (Dali::Actor *)jarg1;
35449   arg2 = (Dali::Vector3 *)jarg2;
35450   if (!arg2) {
35451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35452     return ;
35453   }
35454   {
35455     try {
35456       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35457     } catch (std::out_of_range& e) {
35458       {
35459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35460       };
35461     } catch (std::exception& e) {
35462       {
35463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35464       };
35465     } catch (Dali::DaliException e) {
35466       {
35467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35468       };
35469     } catch (...) {
35470       {
35471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35472       };
35473     }
35474   }
35475
35476 }
35477
35478
35479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35480   void * jresult ;
35481   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35482   Dali::Vector3 result;
35483
35484   arg1 = (Dali::Actor *)jarg1;
35485   {
35486     try {
35487       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35488     } catch (std::out_of_range& e) {
35489       {
35490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35491       };
35492     } catch (std::exception& e) {
35493       {
35494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35495       };
35496     } catch (Dali::DaliException e) {
35497       {
35498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35499       };
35500     } catch (...) {
35501       {
35502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35503       };
35504     }
35505   }
35506
35507   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35508   return jresult;
35509 }
35510
35511
35512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35513   void * jresult ;
35514   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35515   Dali::Vector3 result;
35516
35517   arg1 = (Dali::Actor *)jarg1;
35518   {
35519     try {
35520       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35521     } catch (std::out_of_range& e) {
35522       {
35523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35524       };
35525     } catch (std::exception& e) {
35526       {
35527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35528       };
35529     } catch (Dali::DaliException e) {
35530       {
35531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35532       };
35533     } catch (...) {
35534       {
35535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35536       };
35537     }
35538   }
35539
35540   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35541   return jresult;
35542 }
35543
35544
35545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35546   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35547   bool arg2 ;
35548
35549   arg1 = (Dali::Actor *)jarg1;
35550   arg2 = jarg2 ? true : false;
35551   {
35552     try {
35553       (arg1)->SetInheritScale(arg2);
35554     } catch (std::out_of_range& e) {
35555       {
35556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35557       };
35558     } catch (std::exception& e) {
35559       {
35560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35561       };
35562     } catch (Dali::DaliException e) {
35563       {
35564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35565       };
35566     } catch (...) {
35567       {
35568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35569       };
35570     }
35571   }
35572
35573 }
35574
35575
35576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35577   unsigned int jresult ;
35578   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35579   bool result;
35580
35581   arg1 = (Dali::Actor *)jarg1;
35582   {
35583     try {
35584       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35585     } catch (std::out_of_range& e) {
35586       {
35587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35588       };
35589     } catch (std::exception& e) {
35590       {
35591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35592       };
35593     } catch (Dali::DaliException e) {
35594       {
35595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35596       };
35597     } catch (...) {
35598       {
35599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35600       };
35601     }
35602   }
35603
35604   jresult = result;
35605   return jresult;
35606 }
35607
35608
35609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35610   void * jresult ;
35611   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35612   Dali::Matrix result;
35613
35614   arg1 = (Dali::Actor *)jarg1;
35615   {
35616     try {
35617       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35618     } catch (std::out_of_range& e) {
35619       {
35620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35621       };
35622     } catch (std::exception& e) {
35623       {
35624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35625       };
35626     } catch (Dali::DaliException e) {
35627       {
35628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35629       };
35630     } catch (...) {
35631       {
35632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35633       };
35634     }
35635   }
35636
35637   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35638   return jresult;
35639 }
35640
35641
35642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35643   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35644   bool arg2 ;
35645
35646   arg1 = (Dali::Actor *)jarg1;
35647   arg2 = jarg2 ? true : false;
35648   {
35649     try {
35650       (arg1)->SetVisible(arg2);
35651     } catch (std::out_of_range& e) {
35652       {
35653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35654       };
35655     } catch (std::exception& e) {
35656       {
35657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35658       };
35659     } catch (Dali::DaliException e) {
35660       {
35661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35662       };
35663     } catch (...) {
35664       {
35665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35666       };
35667     }
35668   }
35669
35670 }
35671
35672
35673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35674   unsigned int jresult ;
35675   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35676   bool result;
35677
35678   arg1 = (Dali::Actor *)jarg1;
35679   {
35680     try {
35681       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35682     } catch (std::out_of_range& e) {
35683       {
35684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35685       };
35686     } catch (std::exception& e) {
35687       {
35688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35689       };
35690     } catch (Dali::DaliException e) {
35691       {
35692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35693       };
35694     } catch (...) {
35695       {
35696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35697       };
35698     }
35699   }
35700
35701   jresult = result;
35702   return jresult;
35703 }
35704
35705
35706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35707   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35708   float arg2 ;
35709
35710   arg1 = (Dali::Actor *)jarg1;
35711   arg2 = (float)jarg2;
35712   {
35713     try {
35714       (arg1)->SetOpacity(arg2);
35715     } catch (std::out_of_range& e) {
35716       {
35717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35718       };
35719     } catch (std::exception& e) {
35720       {
35721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35722       };
35723     } catch (Dali::DaliException e) {
35724       {
35725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35726       };
35727     } catch (...) {
35728       {
35729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35730       };
35731     }
35732   }
35733
35734 }
35735
35736
35737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35738   float jresult ;
35739   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35740   float result;
35741
35742   arg1 = (Dali::Actor *)jarg1;
35743   {
35744     try {
35745       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35746     } catch (std::out_of_range& e) {
35747       {
35748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35749       };
35750     } catch (std::exception& e) {
35751       {
35752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35753       };
35754     } catch (Dali::DaliException e) {
35755       {
35756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35757       };
35758     } catch (...) {
35759       {
35760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35761       };
35762     }
35763   }
35764
35765   jresult = result;
35766   return jresult;
35767 }
35768
35769
35770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35771   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35772   Dali::Vector4 *arg2 = 0 ;
35773
35774   arg1 = (Dali::Actor *)jarg1;
35775   arg2 = (Dali::Vector4 *)jarg2;
35776   if (!arg2) {
35777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35778     return ;
35779   }
35780   {
35781     try {
35782       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35783     } catch (std::out_of_range& e) {
35784       {
35785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35786       };
35787     } catch (std::exception& e) {
35788       {
35789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35790       };
35791     } catch (Dali::DaliException e) {
35792       {
35793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35794       };
35795     } catch (...) {
35796       {
35797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35798       };
35799     }
35800   }
35801
35802 }
35803
35804
35805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35806   void * jresult ;
35807   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35808   Dali::Vector4 result;
35809
35810   arg1 = (Dali::Actor *)jarg1;
35811   {
35812     try {
35813       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35814     } catch (std::out_of_range& e) {
35815       {
35816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35817       };
35818     } catch (std::exception& e) {
35819       {
35820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35821       };
35822     } catch (Dali::DaliException e) {
35823       {
35824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35825       };
35826     } catch (...) {
35827       {
35828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35829       };
35830     }
35831   }
35832
35833   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35834   return jresult;
35835 }
35836
35837
35838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35839   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35840   Dali::ColorMode arg2 ;
35841
35842   arg1 = (Dali::Actor *)jarg1;
35843   arg2 = (Dali::ColorMode)jarg2;
35844   {
35845     try {
35846       (arg1)->SetColorMode(arg2);
35847     } catch (std::out_of_range& e) {
35848       {
35849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35850       };
35851     } catch (std::exception& e) {
35852       {
35853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35854       };
35855     } catch (Dali::DaliException e) {
35856       {
35857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35858       };
35859     } catch (...) {
35860       {
35861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35862       };
35863     }
35864   }
35865
35866 }
35867
35868
35869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35870   int jresult ;
35871   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35872   Dali::ColorMode result;
35873
35874   arg1 = (Dali::Actor *)jarg1;
35875   {
35876     try {
35877       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35878     } catch (std::out_of_range& e) {
35879       {
35880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35881       };
35882     } catch (std::exception& e) {
35883       {
35884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35885       };
35886     } catch (Dali::DaliException e) {
35887       {
35888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35889       };
35890     } catch (...) {
35891       {
35892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35893       };
35894     }
35895   }
35896
35897   jresult = (int)result;
35898   return jresult;
35899 }
35900
35901
35902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35903   void * jresult ;
35904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35905   Dali::Vector4 result;
35906
35907   arg1 = (Dali::Actor *)jarg1;
35908   {
35909     try {
35910       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35911     } catch (std::out_of_range& e) {
35912       {
35913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35914       };
35915     } catch (std::exception& e) {
35916       {
35917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35918       };
35919     } catch (Dali::DaliException e) {
35920       {
35921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35922       };
35923     } catch (...) {
35924       {
35925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35926       };
35927     }
35928   }
35929
35930   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35931   return jresult;
35932 }
35933
35934
35935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35936   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35937   Dali::DrawMode::Type arg2 ;
35938
35939   arg1 = (Dali::Actor *)jarg1;
35940   arg2 = (Dali::DrawMode::Type)jarg2;
35941   {
35942     try {
35943       (arg1)->SetDrawMode(arg2);
35944     } catch (std::out_of_range& e) {
35945       {
35946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35947       };
35948     } catch (std::exception& e) {
35949       {
35950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35951       };
35952     } catch (Dali::DaliException e) {
35953       {
35954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35955       };
35956     } catch (...) {
35957       {
35958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35959       };
35960     }
35961   }
35962
35963 }
35964
35965
35966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35967   int jresult ;
35968   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35969   Dali::DrawMode::Type result;
35970
35971   arg1 = (Dali::Actor *)jarg1;
35972   {
35973     try {
35974       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35975     } catch (std::out_of_range& e) {
35976       {
35977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35978       };
35979     } catch (std::exception& e) {
35980       {
35981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35982       };
35983     } catch (Dali::DaliException e) {
35984       {
35985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35986       };
35987     } catch (...) {
35988       {
35989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35990       };
35991     }
35992   }
35993
35994   jresult = (int)result;
35995   return jresult;
35996 }
35997
35998
35999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36001   bool arg2 ;
36002
36003   arg1 = (Dali::Actor *)jarg1;
36004   arg2 = jarg2 ? true : false;
36005   {
36006     try {
36007       (arg1)->SetSensitive(arg2);
36008     } catch (std::out_of_range& e) {
36009       {
36010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36011       };
36012     } catch (std::exception& e) {
36013       {
36014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36015       };
36016     } catch (Dali::DaliException e) {
36017       {
36018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36019       };
36020     } catch (...) {
36021       {
36022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36023       };
36024     }
36025   }
36026
36027 }
36028
36029
36030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36031   unsigned int jresult ;
36032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36033   bool result;
36034
36035   arg1 = (Dali::Actor *)jarg1;
36036   {
36037     try {
36038       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36039     } catch (std::out_of_range& e) {
36040       {
36041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36042       };
36043     } catch (std::exception& e) {
36044       {
36045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36046       };
36047     } catch (Dali::DaliException e) {
36048       {
36049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36050       };
36051     } catch (...) {
36052       {
36053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36054       };
36055     }
36056   }
36057
36058   jresult = result;
36059   return jresult;
36060 }
36061
36062
36063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36064   unsigned int jresult ;
36065   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36066   float *arg2 = 0 ;
36067   float *arg3 = 0 ;
36068   float arg4 ;
36069   float arg5 ;
36070   bool result;
36071
36072   arg1 = (Dali::Actor *)jarg1;
36073   arg2 = (float *)jarg2;
36074   arg3 = (float *)jarg3;
36075   arg4 = (float)jarg4;
36076   arg5 = (float)jarg5;
36077   {
36078     try {
36079       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36080     } catch (std::out_of_range& e) {
36081       {
36082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36083       };
36084     } catch (std::exception& e) {
36085       {
36086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36087       };
36088     } catch (Dali::DaliException e) {
36089       {
36090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36091       };
36092     } catch (...) {
36093       {
36094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36095       };
36096     }
36097   }
36098
36099   jresult = result;
36100   return jresult;
36101 }
36102
36103
36104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36106   bool arg2 ;
36107
36108   arg1 = (Dali::Actor *)jarg1;
36109   arg2 = jarg2 ? true : false;
36110   {
36111     try {
36112       (arg1)->SetLeaveRequired(arg2);
36113     } catch (std::out_of_range& e) {
36114       {
36115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36116       };
36117     } catch (std::exception& e) {
36118       {
36119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36120       };
36121     } catch (Dali::DaliException e) {
36122       {
36123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36124       };
36125     } catch (...) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36128       };
36129     }
36130   }
36131
36132 }
36133
36134
36135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36136   unsigned int jresult ;
36137   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36138   bool result;
36139
36140   arg1 = (Dali::Actor *)jarg1;
36141   {
36142     try {
36143       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36144     } catch (std::out_of_range& e) {
36145       {
36146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36147       };
36148     } catch (std::exception& e) {
36149       {
36150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36151       };
36152     } catch (Dali::DaliException e) {
36153       {
36154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36155       };
36156     } catch (...) {
36157       {
36158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36159       };
36160     }
36161   }
36162
36163   jresult = result;
36164   return jresult;
36165 }
36166
36167
36168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36170   bool arg2 ;
36171
36172   arg1 = (Dali::Actor *)jarg1;
36173   arg2 = jarg2 ? true : false;
36174   {
36175     try {
36176       (arg1)->SetKeyboardFocusable(arg2);
36177     } catch (std::out_of_range& e) {
36178       {
36179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36180       };
36181     } catch (std::exception& e) {
36182       {
36183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36184       };
36185     } catch (Dali::DaliException e) {
36186       {
36187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36188       };
36189     } catch (...) {
36190       {
36191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36192       };
36193     }
36194   }
36195
36196 }
36197
36198
36199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36200   unsigned int jresult ;
36201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36202   bool result;
36203
36204   arg1 = (Dali::Actor *)jarg1;
36205   {
36206     try {
36207       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36208     } catch (std::out_of_range& e) {
36209       {
36210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36211       };
36212     } catch (std::exception& e) {
36213       {
36214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36215       };
36216     } catch (Dali::DaliException e) {
36217       {
36218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36219       };
36220     } catch (...) {
36221       {
36222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36223       };
36224     }
36225   }
36226
36227   jresult = result;
36228   return jresult;
36229 }
36230
36231
36232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36233   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36234   Dali::ResizePolicy::Type arg2 ;
36235   Dali::Dimension::Type arg3 ;
36236
36237   arg1 = (Dali::Actor *)jarg1;
36238   arg2 = (Dali::ResizePolicy::Type)jarg2;
36239   arg3 = (Dali::Dimension::Type)jarg3;
36240   {
36241     try {
36242       (arg1)->SetResizePolicy(arg2,arg3);
36243     } catch (std::out_of_range& e) {
36244       {
36245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36246       };
36247     } catch (std::exception& e) {
36248       {
36249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36250       };
36251     } catch (Dali::DaliException e) {
36252       {
36253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36254       };
36255     } catch (...) {
36256       {
36257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36258       };
36259     }
36260   }
36261
36262 }
36263
36264
36265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36266   int jresult ;
36267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36268   Dali::Dimension::Type arg2 ;
36269   Dali::ResizePolicy::Type result;
36270
36271   arg1 = (Dali::Actor *)jarg1;
36272   arg2 = (Dali::Dimension::Type)jarg2;
36273   {
36274     try {
36275       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36276     } catch (std::out_of_range& e) {
36277       {
36278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36279       };
36280     } catch (std::exception& e) {
36281       {
36282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36283       };
36284     } catch (Dali::DaliException e) {
36285       {
36286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36287       };
36288     } catch (...) {
36289       {
36290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36291       };
36292     }
36293   }
36294
36295   jresult = (int)result;
36296   return jresult;
36297 }
36298
36299
36300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36302   Dali::SizeScalePolicy::Type arg2 ;
36303
36304   arg1 = (Dali::Actor *)jarg1;
36305   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36306   {
36307     try {
36308       (arg1)->SetSizeScalePolicy(arg2);
36309     } catch (std::out_of_range& e) {
36310       {
36311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36312       };
36313     } catch (std::exception& e) {
36314       {
36315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36316       };
36317     } catch (Dali::DaliException e) {
36318       {
36319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36320       };
36321     } catch (...) {
36322       {
36323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36324       };
36325     }
36326   }
36327
36328 }
36329
36330
36331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36332   int jresult ;
36333   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36334   Dali::SizeScalePolicy::Type result;
36335
36336   arg1 = (Dali::Actor *)jarg1;
36337   {
36338     try {
36339       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36340     } catch (std::out_of_range& e) {
36341       {
36342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36343       };
36344     } catch (std::exception& e) {
36345       {
36346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36347       };
36348     } catch (Dali::DaliException e) {
36349       {
36350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36351       };
36352     } catch (...) {
36353       {
36354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36355       };
36356     }
36357   }
36358
36359   jresult = (int)result;
36360   return jresult;
36361 }
36362
36363
36364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36366   Dali::Vector3 *arg2 = 0 ;
36367
36368   arg1 = (Dali::Actor *)jarg1;
36369   arg2 = (Dali::Vector3 *)jarg2;
36370   if (!arg2) {
36371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36372     return ;
36373   }
36374   {
36375     try {
36376       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36377     } catch (std::out_of_range& e) {
36378       {
36379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36380       };
36381     } catch (std::exception& e) {
36382       {
36383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36384       };
36385     } catch (Dali::DaliException e) {
36386       {
36387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36388       };
36389     } catch (...) {
36390       {
36391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36392       };
36393     }
36394   }
36395
36396 }
36397
36398
36399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36400   void * jresult ;
36401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36402   Dali::Vector3 result;
36403
36404   arg1 = (Dali::Actor *)jarg1;
36405   {
36406     try {
36407       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36408     } catch (std::out_of_range& e) {
36409       {
36410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36411       };
36412     } catch (std::exception& e) {
36413       {
36414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36415       };
36416     } catch (Dali::DaliException e) {
36417       {
36418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36419       };
36420     } catch (...) {
36421       {
36422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36423       };
36424     }
36425   }
36426
36427   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36428   return jresult;
36429 }
36430
36431
36432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36433   float jresult ;
36434   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36435   float arg2 ;
36436   float result;
36437
36438   arg1 = (Dali::Actor *)jarg1;
36439   arg2 = (float)jarg2;
36440   {
36441     try {
36442       result = (float)(arg1)->GetHeightForWidth(arg2);
36443     } catch (std::out_of_range& e) {
36444       {
36445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36446       };
36447     } catch (std::exception& e) {
36448       {
36449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36450       };
36451     } catch (Dali::DaliException e) {
36452       {
36453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36454       };
36455     } catch (...) {
36456       {
36457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36458       };
36459     }
36460   }
36461
36462   jresult = result;
36463   return jresult;
36464 }
36465
36466
36467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36468   float jresult ;
36469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36470   float arg2 ;
36471   float result;
36472
36473   arg1 = (Dali::Actor *)jarg1;
36474   arg2 = (float)jarg2;
36475   {
36476     try {
36477       result = (float)(arg1)->GetWidthForHeight(arg2);
36478     } catch (std::out_of_range& e) {
36479       {
36480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36481       };
36482     } catch (std::exception& e) {
36483       {
36484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36485       };
36486     } catch (Dali::DaliException e) {
36487       {
36488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36489       };
36490     } catch (...) {
36491       {
36492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36493       };
36494     }
36495   }
36496
36497   jresult = result;
36498   return jresult;
36499 }
36500
36501
36502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36503   float jresult ;
36504   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36505   Dali::Dimension::Type arg2 ;
36506   float result;
36507
36508   arg1 = (Dali::Actor *)jarg1;
36509   arg2 = (Dali::Dimension::Type)jarg2;
36510   {
36511     try {
36512       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36513     } catch (std::out_of_range& e) {
36514       {
36515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36516       };
36517     } catch (std::exception& e) {
36518       {
36519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36520       };
36521     } catch (Dali::DaliException e) {
36522       {
36523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36524       };
36525     } catch (...) {
36526       {
36527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36528       };
36529     }
36530   }
36531
36532   jresult = result;
36533   return jresult;
36534 }
36535
36536
36537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36539   Dali::Padding *arg2 = 0 ;
36540
36541   arg1 = (Dali::Actor *)jarg1;
36542   arg2 = (Dali::Padding *)jarg2;
36543   if (!arg2) {
36544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36545     return ;
36546   }
36547   {
36548     try {
36549       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36550     } catch (std::out_of_range& e) {
36551       {
36552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36553       };
36554     } catch (std::exception& e) {
36555       {
36556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36557       };
36558     } catch (Dali::DaliException e) {
36559       {
36560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36561       };
36562     } catch (...) {
36563       {
36564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36565       };
36566     }
36567   }
36568
36569 }
36570
36571
36572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36573   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36574   Dali::Padding *arg2 = 0 ;
36575
36576   arg1 = (Dali::Actor *)jarg1;
36577   arg2 = (Dali::Padding *)jarg2;
36578   if (!arg2) {
36579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36580     return ;
36581   }
36582   {
36583     try {
36584       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36585     } catch (std::out_of_range& e) {
36586       {
36587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36588       };
36589     } catch (std::exception& e) {
36590       {
36591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36592       };
36593     } catch (Dali::DaliException e) {
36594       {
36595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36596       };
36597     } catch (...) {
36598       {
36599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36600       };
36601     }
36602   }
36603
36604 }
36605
36606
36607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36608   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36609   Dali::Vector2 *arg2 = 0 ;
36610
36611   arg1 = (Dali::Actor *)jarg1;
36612   arg2 = (Dali::Vector2 *)jarg2;
36613   if (!arg2) {
36614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36615     return ;
36616   }
36617   {
36618     try {
36619       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36620     } catch (std::out_of_range& e) {
36621       {
36622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36623       };
36624     } catch (std::exception& e) {
36625       {
36626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36627       };
36628     } catch (Dali::DaliException e) {
36629       {
36630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36631       };
36632     } catch (...) {
36633       {
36634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36635       };
36636     }
36637   }
36638
36639 }
36640
36641
36642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36643   void * jresult ;
36644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36645   Dali::Vector2 result;
36646
36647   arg1 = (Dali::Actor *)jarg1;
36648   {
36649     try {
36650       result = (arg1)->GetMinimumSize();
36651     } catch (std::out_of_range& e) {
36652       {
36653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36654       };
36655     } catch (std::exception& e) {
36656       {
36657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36658       };
36659     } catch (Dali::DaliException e) {
36660       {
36661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36662       };
36663     } catch (...) {
36664       {
36665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36666       };
36667     }
36668   }
36669
36670   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36671   return jresult;
36672 }
36673
36674
36675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36677   Dali::Vector2 *arg2 = 0 ;
36678
36679   arg1 = (Dali::Actor *)jarg1;
36680   arg2 = (Dali::Vector2 *)jarg2;
36681   if (!arg2) {
36682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36683     return ;
36684   }
36685   {
36686     try {
36687       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36688     } catch (std::out_of_range& e) {
36689       {
36690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36691       };
36692     } catch (std::exception& e) {
36693       {
36694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36695       };
36696     } catch (Dali::DaliException e) {
36697       {
36698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36699       };
36700     } catch (...) {
36701       {
36702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36703       };
36704     }
36705   }
36706
36707 }
36708
36709
36710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36711   void * jresult ;
36712   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36713   Dali::Vector2 result;
36714
36715   arg1 = (Dali::Actor *)jarg1;
36716   {
36717     try {
36718       result = (arg1)->GetMaximumSize();
36719     } catch (std::out_of_range& e) {
36720       {
36721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36722       };
36723     } catch (std::exception& e) {
36724       {
36725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36726       };
36727     } catch (Dali::DaliException e) {
36728       {
36729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36730       };
36731     } catch (...) {
36732       {
36733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36734       };
36735     }
36736   }
36737
36738   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36739   return jresult;
36740 }
36741
36742
36743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36744   int jresult ;
36745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36746   int result;
36747
36748   arg1 = (Dali::Actor *)jarg1;
36749   {
36750     try {
36751       result = (int)(arg1)->GetHierarchyDepth();
36752       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
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_AddRenderer(void * jarg1, void * jarg2) {
36778   unsigned int jresult ;
36779   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36780   Dali::Renderer *arg2 = 0 ;
36781   unsigned int result;
36782
36783   arg1 = (Dali::Actor *)jarg1;
36784   arg2 = (Dali::Renderer *)jarg2;
36785   if (!arg2) {
36786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36787     return 0;
36788   }
36789   {
36790     try {
36791       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36792     } catch (std::out_of_range& e) {
36793       {
36794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36795       };
36796     } catch (std::exception& e) {
36797       {
36798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36799       };
36800     } catch (Dali::DaliException e) {
36801       {
36802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36803       };
36804     } catch (...) {
36805       {
36806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36807       };
36808     }
36809   }
36810
36811   jresult = result;
36812   return jresult;
36813 }
36814
36815
36816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36817   unsigned int jresult ;
36818   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36819   unsigned int result;
36820
36821   arg1 = (Dali::Actor *)jarg1;
36822   {
36823     try {
36824       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36825     } catch (std::out_of_range& e) {
36826       {
36827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36828       };
36829     } catch (std::exception& e) {
36830       {
36831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36832       };
36833     } catch (Dali::DaliException e) {
36834       {
36835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36836       };
36837     } catch (...) {
36838       {
36839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36840       };
36841     }
36842   }
36843
36844   jresult = result;
36845   return jresult;
36846 }
36847
36848
36849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36850   void * jresult ;
36851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36852   unsigned int arg2 ;
36853   Dali::Renderer result;
36854
36855   arg1 = (Dali::Actor *)jarg1;
36856   arg2 = (unsigned int)jarg2;
36857   {
36858     try {
36859       result = (arg1)->GetRendererAt(arg2);
36860     } catch (std::out_of_range& e) {
36861       {
36862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36863       };
36864     } catch (std::exception& e) {
36865       {
36866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36867       };
36868     } catch (Dali::DaliException e) {
36869       {
36870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36871       };
36872     } catch (...) {
36873       {
36874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36875       };
36876     }
36877   }
36878
36879   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36880   return jresult;
36881 }
36882
36883
36884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36886   Dali::Renderer *arg2 = 0 ;
36887
36888   arg1 = (Dali::Actor *)jarg1;
36889   arg2 = (Dali::Renderer *)jarg2;
36890   if (!arg2) {
36891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36892     return ;
36893   }
36894   {
36895     try {
36896       (arg1)->RemoveRenderer(*arg2);
36897     } catch (std::out_of_range& e) {
36898       {
36899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36900       };
36901     } catch (std::exception& e) {
36902       {
36903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36904       };
36905     } catch (Dali::DaliException e) {
36906       {
36907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36908       };
36909     } catch (...) {
36910       {
36911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36912       };
36913     }
36914   }
36915
36916 }
36917
36918
36919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36920   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36921   unsigned int arg2 ;
36922
36923   arg1 = (Dali::Actor *)jarg1;
36924   arg2 = (unsigned int)jarg2;
36925   {
36926     try {
36927       (arg1)->RemoveRenderer(arg2);
36928     } catch (std::out_of_range& e) {
36929       {
36930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36931       };
36932     } catch (std::exception& e) {
36933       {
36934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36935       };
36936     } catch (Dali::DaliException e) {
36937       {
36938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36939       };
36940     } catch (...) {
36941       {
36942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36943       };
36944     }
36945   }
36946
36947 }
36948
36949
36950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36951   void * jresult ;
36952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36953   Dali::Actor::TouchSignalType *result = 0 ;
36954
36955   arg1 = (Dali::Actor *)jarg1;
36956   {
36957     try {
36958       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36959     } catch (std::out_of_range& e) {
36960       {
36961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36962       };
36963     } catch (std::exception& e) {
36964       {
36965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36966       };
36967     } catch (Dali::DaliException e) {
36968       {
36969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36970       };
36971     } catch (...) {
36972       {
36973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36974       };
36975     }
36976   }
36977
36978   jresult = (void *)result;
36979   return jresult;
36980 }
36981
36982
36983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36984   void * jresult ;
36985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36986   Dali::Actor::TouchDataSignalType *result = 0 ;
36987
36988   arg1 = (Dali::Actor *)jarg1;
36989   {
36990     try {
36991       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36992     } catch (std::out_of_range& e) {
36993       {
36994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36995       };
36996     } catch (std::exception& e) {
36997       {
36998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36999       };
37000     } catch (Dali::DaliException e) {
37001       {
37002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37003       };
37004     } catch (...) {
37005       {
37006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37007       };
37008     }
37009   }
37010
37011   jresult = (void *)result;
37012   return jresult;
37013 }
37014
37015
37016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37017   void * jresult ;
37018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37019   Dali::Actor::HoverSignalType *result = 0 ;
37020
37021   arg1 = (Dali::Actor *)jarg1;
37022   {
37023     try {
37024       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37025     } catch (std::out_of_range& e) {
37026       {
37027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37028       };
37029     } catch (std::exception& e) {
37030       {
37031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37032       };
37033     } catch (Dali::DaliException e) {
37034       {
37035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37036       };
37037     } catch (...) {
37038       {
37039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37040       };
37041     }
37042   }
37043
37044   jresult = (void *)result;
37045   return jresult;
37046 }
37047
37048
37049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37050   void * jresult ;
37051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37052   Dali::Actor::WheelEventSignalType *result = 0 ;
37053
37054   arg1 = (Dali::Actor *)jarg1;
37055   {
37056     try {
37057       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37058     } catch (std::out_of_range& e) {
37059       {
37060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37061       };
37062     } catch (std::exception& e) {
37063       {
37064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37065       };
37066     } catch (Dali::DaliException e) {
37067       {
37068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37069       };
37070     } catch (...) {
37071       {
37072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37073       };
37074     }
37075   }
37076
37077   jresult = (void *)result;
37078   return jresult;
37079 }
37080
37081
37082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37083   void * jresult ;
37084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37085   Dali::Actor::OnStageSignalType *result = 0 ;
37086
37087   arg1 = (Dali::Actor *)jarg1;
37088   {
37089     try {
37090       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37091     } catch (std::out_of_range& e) {
37092       {
37093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37094       };
37095     } catch (std::exception& e) {
37096       {
37097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37098       };
37099     } catch (Dali::DaliException e) {
37100       {
37101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37102       };
37103     } catch (...) {
37104       {
37105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37106       };
37107     }
37108   }
37109
37110   jresult = (void *)result;
37111   return jresult;
37112 }
37113
37114
37115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37116   void * jresult ;
37117   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37118   Dali::Actor::OffStageSignalType *result = 0 ;
37119
37120   arg1 = (Dali::Actor *)jarg1;
37121   {
37122     try {
37123       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37124     } catch (std::out_of_range& e) {
37125       {
37126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37127       };
37128     } catch (std::exception& e) {
37129       {
37130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37131       };
37132     } catch (Dali::DaliException e) {
37133       {
37134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37135       };
37136     } catch (...) {
37137       {
37138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37139       };
37140     }
37141   }
37142
37143   jresult = (void *)result;
37144   return jresult;
37145 }
37146
37147
37148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37149   void * jresult ;
37150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37151   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37152
37153   arg1 = (Dali::Actor *)jarg1;
37154   {
37155     try {
37156       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37157     } catch (std::out_of_range& e) {
37158       {
37159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37160       };
37161     } catch (std::exception& e) {
37162       {
37163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37164       };
37165     } catch (Dali::DaliException e) {
37166       {
37167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37168       };
37169     } catch (...) {
37170       {
37171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37172       };
37173     }
37174   }
37175
37176   jresult = (void *)result;
37177   return jresult;
37178 }
37179
37180
37181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37182   Dali::Actor *arg1 = 0 ;
37183
37184   arg1 = (Dali::Actor *)jarg1;
37185   if (!arg1) {
37186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37187     return ;
37188   }
37189   {
37190     try {
37191       Dali::UnparentAndReset(*arg1);
37192     } catch (std::out_of_range& e) {
37193       {
37194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37195       };
37196     } catch (std::exception& e) {
37197       {
37198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37199       };
37200     } catch (Dali::DaliException e) {
37201       {
37202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37203       };
37204     } catch (...) {
37205       {
37206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37207       };
37208     }
37209   }
37210
37211 }
37212
37213
37214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37215   int jresult ;
37216   int result;
37217
37218   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37219   jresult = (int)result;
37220   return jresult;
37221 }
37222
37223
37224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37225   int jresult ;
37226   int result;
37227
37228   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37229   jresult = (int)result;
37230   return jresult;
37231 }
37232
37233
37234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37235   int jresult ;
37236   int result;
37237
37238   result = (int)Dali::Layer::Property::BEHAVIOR;
37239   jresult = (int)result;
37240   return jresult;
37241 }
37242
37243
37244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37245   void * jresult ;
37246   Dali::Layer::Property *result = 0 ;
37247
37248   {
37249     try {
37250       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37251     } catch (std::out_of_range& e) {
37252       {
37253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37254       };
37255     } catch (std::exception& e) {
37256       {
37257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37258       };
37259     } catch (Dali::DaliException e) {
37260       {
37261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37262       };
37263     } catch (...) {
37264       {
37265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37266       };
37267     }
37268   }
37269
37270   jresult = (void *)result;
37271   return jresult;
37272 }
37273
37274
37275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37276   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37277
37278   arg1 = (Dali::Layer::Property *)jarg1;
37279   {
37280     try {
37281       delete arg1;
37282     } catch (std::out_of_range& e) {
37283       {
37284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37285       };
37286     } catch (std::exception& e) {
37287       {
37288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37289       };
37290     } catch (Dali::DaliException e) {
37291       {
37292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37293       };
37294     } catch (...) {
37295       {
37296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37297       };
37298     }
37299   }
37300
37301 }
37302
37303
37304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37305   void * jresult ;
37306   Dali::Layer *result = 0 ;
37307
37308   {
37309     try {
37310       result = (Dali::Layer *)new Dali::Layer();
37311     } catch (std::out_of_range& e) {
37312       {
37313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37314       };
37315     } catch (std::exception& e) {
37316       {
37317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37318       };
37319     } catch (Dali::DaliException e) {
37320       {
37321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37322       };
37323     } catch (...) {
37324       {
37325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37326       };
37327     }
37328   }
37329
37330   jresult = (void *)result;
37331   return jresult;
37332 }
37333
37334
37335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37336   void * jresult ;
37337   Dali::Layer result;
37338
37339   {
37340     try {
37341       result = Dali::Layer::New();
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_Layer_DownCast(void * jarg1) {
37367   void * jresult ;
37368   Dali::BaseHandle arg1 ;
37369   Dali::BaseHandle *argp1 ;
37370   Dali::Layer result;
37371
37372   argp1 = (Dali::BaseHandle *)jarg1;
37373   if (!argp1) {
37374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37375     return 0;
37376   }
37377   arg1 = *argp1;
37378   {
37379     try {
37380       result = Dali::Layer::DownCast(arg1);
37381     } catch (std::out_of_range& e) {
37382       {
37383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37384       };
37385     } catch (std::exception& e) {
37386       {
37387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37388       };
37389     } catch (Dali::DaliException e) {
37390       {
37391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37392       };
37393     } catch (...) {
37394       {
37395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37396       };
37397     }
37398   }
37399
37400   jresult = new Dali::Layer((const Dali::Layer &)result);
37401   return jresult;
37402 }
37403
37404
37405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37406   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37407
37408   arg1 = (Dali::Layer *)jarg1;
37409   {
37410     try {
37411       delete arg1;
37412     } catch (std::out_of_range& e) {
37413       {
37414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37415       };
37416     } catch (std::exception& e) {
37417       {
37418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37419       };
37420     } catch (Dali::DaliException e) {
37421       {
37422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37423       };
37424     } catch (...) {
37425       {
37426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37427       };
37428     }
37429   }
37430
37431 }
37432
37433
37434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37435   void * jresult ;
37436   Dali::Layer *arg1 = 0 ;
37437   Dali::Layer *result = 0 ;
37438
37439   arg1 = (Dali::Layer *)jarg1;
37440   if (!arg1) {
37441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37442     return 0;
37443   }
37444   {
37445     try {
37446       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
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 void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37472   void * jresult ;
37473   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37474   Dali::Layer *arg2 = 0 ;
37475   Dali::Layer *result = 0 ;
37476
37477   arg1 = (Dali::Layer *)jarg1;
37478   arg2 = (Dali::Layer *)jarg2;
37479   if (!arg2) {
37480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37481     return 0;
37482   }
37483   {
37484     try {
37485       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37486     } catch (std::out_of_range& e) {
37487       {
37488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37489       };
37490     } catch (std::exception& e) {
37491       {
37492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37493       };
37494     } catch (Dali::DaliException e) {
37495       {
37496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37497       };
37498     } catch (...) {
37499       {
37500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37501       };
37502     }
37503   }
37504
37505   jresult = (void *)result;
37506   return jresult;
37507 }
37508
37509
37510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37511   unsigned int jresult ;
37512   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37513   unsigned int result;
37514
37515   arg1 = (Dali::Layer *)jarg1;
37516   {
37517     try {
37518       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37519     } catch (std::out_of_range& e) {
37520       {
37521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37522       };
37523     } catch (std::exception& e) {
37524       {
37525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37526       };
37527     } catch (Dali::DaliException e) {
37528       {
37529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37530       };
37531     } catch (...) {
37532       {
37533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37534       };
37535     }
37536   }
37537
37538   jresult = result;
37539   return jresult;
37540 }
37541
37542
37543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37544   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37545
37546   arg1 = (Dali::Layer *)jarg1;
37547   {
37548     try {
37549       (arg1)->Raise();
37550     } catch (std::out_of_range& e) {
37551       {
37552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37553       };
37554     } catch (std::exception& e) {
37555       {
37556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37557       };
37558     } catch (Dali::DaliException e) {
37559       {
37560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37561       };
37562     } catch (...) {
37563       {
37564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37565       };
37566     }
37567   }
37568
37569 }
37570
37571
37572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37573   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37574
37575   arg1 = (Dali::Layer *)jarg1;
37576   {
37577     try {
37578       (arg1)->Lower();
37579     } catch (std::out_of_range& e) {
37580       {
37581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37582       };
37583     } catch (std::exception& e) {
37584       {
37585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37586       };
37587     } catch (Dali::DaliException e) {
37588       {
37589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37590       };
37591     } catch (...) {
37592       {
37593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37594       };
37595     }
37596   }
37597
37598 }
37599
37600
37601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37602   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37603   Dali::Layer arg2 ;
37604   Dali::Layer *argp2 ;
37605
37606   arg1 = (Dali::Layer *)jarg1;
37607   argp2 = (Dali::Layer *)jarg2;
37608   if (!argp2) {
37609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37610     return ;
37611   }
37612   arg2 = *argp2;
37613   {
37614     try {
37615       (arg1)->RaiseAbove(arg2);
37616     } catch (std::out_of_range& e) {
37617       {
37618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37619       };
37620     } catch (std::exception& e) {
37621       {
37622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37623       };
37624     } catch (Dali::DaliException e) {
37625       {
37626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37627       };
37628     } catch (...) {
37629       {
37630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37631       };
37632     }
37633   }
37634
37635 }
37636
37637
37638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37639   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37640   Dali::Layer arg2 ;
37641   Dali::Layer *argp2 ;
37642
37643   arg1 = (Dali::Layer *)jarg1;
37644   argp2 = (Dali::Layer *)jarg2;
37645   if (!argp2) {
37646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37647     return ;
37648   }
37649   arg2 = *argp2;
37650   {
37651     try {
37652       (arg1)->LowerBelow(arg2);
37653     } catch (std::out_of_range& e) {
37654       {
37655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37656       };
37657     } catch (std::exception& e) {
37658       {
37659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37660       };
37661     } catch (Dali::DaliException e) {
37662       {
37663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37664       };
37665     } catch (...) {
37666       {
37667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37668       };
37669     }
37670   }
37671
37672 }
37673
37674
37675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37676   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37677
37678   arg1 = (Dali::Layer *)jarg1;
37679   {
37680     try {
37681       (arg1)->RaiseToTop();
37682     } catch (std::out_of_range& e) {
37683       {
37684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37685       };
37686     } catch (std::exception& e) {
37687       {
37688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37689       };
37690     } catch (Dali::DaliException e) {
37691       {
37692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37693       };
37694     } catch (...) {
37695       {
37696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37697       };
37698     }
37699   }
37700
37701 }
37702
37703
37704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37705   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37706
37707   arg1 = (Dali::Layer *)jarg1;
37708   {
37709     try {
37710       (arg1)->LowerToBottom();
37711     } catch (std::out_of_range& e) {
37712       {
37713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37714       };
37715     } catch (std::exception& e) {
37716       {
37717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37718       };
37719     } catch (Dali::DaliException e) {
37720       {
37721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37722       };
37723     } catch (...) {
37724       {
37725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37726       };
37727     }
37728   }
37729
37730 }
37731
37732
37733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37734   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37735   Dali::Layer arg2 ;
37736   Dali::Layer *argp2 ;
37737
37738   arg1 = (Dali::Layer *)jarg1;
37739   argp2 = (Dali::Layer *)jarg2;
37740   if (!argp2) {
37741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37742     return ;
37743   }
37744   arg2 = *argp2;
37745   {
37746     try {
37747       (arg1)->MoveAbove(arg2);
37748     } catch (std::out_of_range& e) {
37749       {
37750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37751       };
37752     } catch (std::exception& e) {
37753       {
37754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37755       };
37756     } catch (Dali::DaliException e) {
37757       {
37758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37759       };
37760     } catch (...) {
37761       {
37762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37763       };
37764     }
37765   }
37766
37767 }
37768
37769
37770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37771   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37772   Dali::Layer arg2 ;
37773   Dali::Layer *argp2 ;
37774
37775   arg1 = (Dali::Layer *)jarg1;
37776   argp2 = (Dali::Layer *)jarg2;
37777   if (!argp2) {
37778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37779     return ;
37780   }
37781   arg2 = *argp2;
37782   {
37783     try {
37784       (arg1)->MoveBelow(arg2);
37785     } catch (std::out_of_range& e) {
37786       {
37787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37788       };
37789     } catch (std::exception& e) {
37790       {
37791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37792       };
37793     } catch (Dali::DaliException e) {
37794       {
37795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37796       };
37797     } catch (...) {
37798       {
37799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37800       };
37801     }
37802   }
37803
37804 }
37805
37806
37807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37808   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37809   Dali::Layer::Behavior arg2 ;
37810
37811   arg1 = (Dali::Layer *)jarg1;
37812   arg2 = (Dali::Layer::Behavior)jarg2;
37813   {
37814     try {
37815       (arg1)->SetBehavior(arg2);
37816     } catch (std::out_of_range& e) {
37817       {
37818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37819       };
37820     } catch (std::exception& e) {
37821       {
37822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37823       };
37824     } catch (Dali::DaliException e) {
37825       {
37826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37827       };
37828     } catch (...) {
37829       {
37830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37831       };
37832     }
37833   }
37834
37835 }
37836
37837
37838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37839   int jresult ;
37840   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37841   Dali::Layer::Behavior result;
37842
37843   arg1 = (Dali::Layer *)jarg1;
37844   {
37845     try {
37846       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37847     } catch (std::out_of_range& e) {
37848       {
37849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37850       };
37851     } catch (std::exception& e) {
37852       {
37853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37854       };
37855     } catch (Dali::DaliException e) {
37856       {
37857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37858       };
37859     } catch (...) {
37860       {
37861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37862       };
37863     }
37864   }
37865
37866   jresult = (int)result;
37867   return jresult;
37868 }
37869
37870
37871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37872   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37873   bool arg2 ;
37874
37875   arg1 = (Dali::Layer *)jarg1;
37876   arg2 = jarg2 ? true : false;
37877   {
37878     try {
37879       (arg1)->SetClipping(arg2);
37880     } catch (std::out_of_range& e) {
37881       {
37882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37883       };
37884     } catch (std::exception& e) {
37885       {
37886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37887       };
37888     } catch (Dali::DaliException e) {
37889       {
37890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37891       };
37892     } catch (...) {
37893       {
37894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37895       };
37896     }
37897   }
37898
37899 }
37900
37901
37902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37903   unsigned int jresult ;
37904   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37905   bool result;
37906
37907   arg1 = (Dali::Layer *)jarg1;
37908   {
37909     try {
37910       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37911     } catch (std::out_of_range& e) {
37912       {
37913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37914       };
37915     } catch (std::exception& e) {
37916       {
37917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37918       };
37919     } catch (Dali::DaliException e) {
37920       {
37921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37922       };
37923     } catch (...) {
37924       {
37925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37926       };
37927     }
37928   }
37929
37930   jresult = result;
37931   return jresult;
37932 }
37933
37934
37935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37936   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37937   int arg2 ;
37938   int arg3 ;
37939   int arg4 ;
37940   int arg5 ;
37941
37942   arg1 = (Dali::Layer *)jarg1;
37943   arg2 = (int)jarg2;
37944   arg3 = (int)jarg3;
37945   arg4 = (int)jarg4;
37946   arg5 = (int)jarg5;
37947   {
37948     try {
37949       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37950     } catch (std::out_of_range& e) {
37951       {
37952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37953       };
37954     } catch (std::exception& e) {
37955       {
37956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37957       };
37958     } catch (Dali::DaliException e) {
37959       {
37960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37961       };
37962     } catch (...) {
37963       {
37964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37965       };
37966     }
37967   }
37968
37969 }
37970
37971
37972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37973   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37974   Dali::ClippingBox arg2 ;
37975   Dali::ClippingBox *argp2 ;
37976
37977   arg1 = (Dali::Layer *)jarg1;
37978   argp2 = (Dali::ClippingBox *)jarg2;
37979   if (!argp2) {
37980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37981     return ;
37982   }
37983   arg2 = *argp2;
37984   {
37985     try {
37986       (arg1)->SetClippingBox(arg2);
37987     } catch (std::out_of_range& e) {
37988       {
37989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37990       };
37991     } catch (std::exception& e) {
37992       {
37993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37994       };
37995     } catch (Dali::DaliException e) {
37996       {
37997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37998       };
37999     } catch (...) {
38000       {
38001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38002       };
38003     }
38004   }
38005
38006 }
38007
38008
38009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38010   void * jresult ;
38011   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38012   Dali::ClippingBox result;
38013
38014   arg1 = (Dali::Layer *)jarg1;
38015   {
38016     try {
38017       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38018     } catch (std::out_of_range& e) {
38019       {
38020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38021       };
38022     } catch (std::exception& e) {
38023       {
38024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38025       };
38026     } catch (Dali::DaliException e) {
38027       {
38028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38029       };
38030     } catch (...) {
38031       {
38032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38033       };
38034     }
38035   }
38036
38037   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38038   return jresult;
38039 }
38040
38041
38042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38043   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38044   bool arg2 ;
38045
38046   arg1 = (Dali::Layer *)jarg1;
38047   arg2 = jarg2 ? true : false;
38048   {
38049     try {
38050       (arg1)->SetDepthTestDisabled(arg2);
38051     } catch (std::out_of_range& e) {
38052       {
38053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38054       };
38055     } catch (std::exception& e) {
38056       {
38057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38058       };
38059     } catch (Dali::DaliException e) {
38060       {
38061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38062       };
38063     } catch (...) {
38064       {
38065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38066       };
38067     }
38068   }
38069
38070 }
38071
38072
38073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38074   unsigned int jresult ;
38075   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38076   bool result;
38077
38078   arg1 = (Dali::Layer *)jarg1;
38079   {
38080     try {
38081       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38082     } catch (std::out_of_range& e) {
38083       {
38084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38085       };
38086     } catch (std::exception& e) {
38087       {
38088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38089       };
38090     } catch (Dali::DaliException e) {
38091       {
38092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38093       };
38094     } catch (...) {
38095       {
38096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38097       };
38098     }
38099   }
38100
38101   jresult = result;
38102   return jresult;
38103 }
38104
38105
38106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38107   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38108   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38109
38110   arg1 = (Dali::Layer *)jarg1;
38111   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38112   {
38113     try {
38114       (arg1)->SetSortFunction(arg2);
38115     } catch (std::out_of_range& e) {
38116       {
38117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38118       };
38119     } catch (std::exception& e) {
38120       {
38121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38122       };
38123     } catch (Dali::DaliException e) {
38124       {
38125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38126       };
38127     } catch (...) {
38128       {
38129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38130       };
38131     }
38132   }
38133
38134 }
38135
38136
38137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38138   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38139   bool arg2 ;
38140
38141   arg1 = (Dali::Layer *)jarg1;
38142   arg2 = jarg2 ? true : false;
38143   {
38144     try {
38145       (arg1)->SetTouchConsumed(arg2);
38146     } catch (std::out_of_range& e) {
38147       {
38148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38149       };
38150     } catch (std::exception& e) {
38151       {
38152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38153       };
38154     } catch (Dali::DaliException e) {
38155       {
38156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38157       };
38158     } catch (...) {
38159       {
38160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38161       };
38162     }
38163   }
38164
38165 }
38166
38167
38168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38169   unsigned int jresult ;
38170   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38171   bool result;
38172
38173   arg1 = (Dali::Layer *)jarg1;
38174   {
38175     try {
38176       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38177     } catch (std::out_of_range& e) {
38178       {
38179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38180       };
38181     } catch (std::exception& e) {
38182       {
38183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38184       };
38185     } catch (Dali::DaliException e) {
38186       {
38187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38188       };
38189     } catch (...) {
38190       {
38191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38192       };
38193     }
38194   }
38195
38196   jresult = result;
38197   return jresult;
38198 }
38199
38200
38201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38202   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38203   bool arg2 ;
38204
38205   arg1 = (Dali::Layer *)jarg1;
38206   arg2 = jarg2 ? true : false;
38207   {
38208     try {
38209       (arg1)->SetHoverConsumed(arg2);
38210     } catch (std::out_of_range& e) {
38211       {
38212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38213       };
38214     } catch (std::exception& e) {
38215       {
38216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38217       };
38218     } catch (Dali::DaliException e) {
38219       {
38220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38221       };
38222     } catch (...) {
38223       {
38224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38225       };
38226     }
38227   }
38228
38229 }
38230
38231
38232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38233   unsigned int jresult ;
38234   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38235   bool result;
38236
38237   arg1 = (Dali::Layer *)jarg1;
38238   {
38239     try {
38240       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38241     } catch (std::out_of_range& e) {
38242       {
38243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38244       };
38245     } catch (std::exception& e) {
38246       {
38247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38248       };
38249     } catch (Dali::DaliException e) {
38250       {
38251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38252       };
38253     } catch (...) {
38254       {
38255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38256       };
38257     }
38258   }
38259
38260   jresult = result;
38261   return jresult;
38262 }
38263
38264
38265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38266   void * jresult ;
38267   Dali::Vector4 *result = 0 ;
38268
38269   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38270   jresult = (void *)result;
38271   return jresult;
38272 }
38273
38274
38275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38276   void * jresult ;
38277   Dali::Vector4 *result = 0 ;
38278
38279   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38280   jresult = (void *)result;
38281   return jresult;
38282 }
38283
38284
38285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38286   void * jresult ;
38287   Dali::Stage *result = 0 ;
38288
38289   {
38290     try {
38291       result = (Dali::Stage *)new Dali::Stage();
38292     } catch (std::out_of_range& e) {
38293       {
38294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38295       };
38296     } catch (std::exception& e) {
38297       {
38298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38299       };
38300     } catch (Dali::DaliException e) {
38301       {
38302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38303       };
38304     } catch (...) {
38305       {
38306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38307       };
38308     }
38309   }
38310
38311   jresult = (void *)result;
38312   return jresult;
38313 }
38314
38315
38316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38317   void * jresult ;
38318   Dali::Stage result;
38319
38320   {
38321     try {
38322       result = Dali::Stage::GetCurrent();
38323     } catch (std::out_of_range& e) {
38324       {
38325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38326       };
38327     } catch (std::exception& e) {
38328       {
38329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38330       };
38331     } catch (Dali::DaliException e) {
38332       {
38333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38334       };
38335     } catch (...) {
38336       {
38337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38338       };
38339     }
38340   }
38341
38342   jresult = new Dali::Stage((const Dali::Stage &)result);
38343   return jresult;
38344 }
38345
38346
38347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38348   unsigned int jresult ;
38349   bool result;
38350
38351   {
38352     try {
38353       result = (bool)Dali::Stage::IsInstalled();
38354     } catch (std::out_of_range& e) {
38355       {
38356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38357       };
38358     } catch (std::exception& e) {
38359       {
38360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38361       };
38362     } catch (Dali::DaliException e) {
38363       {
38364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38365       };
38366     } catch (...) {
38367       {
38368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38369       };
38370     }
38371   }
38372
38373   jresult = result;
38374   return jresult;
38375 }
38376
38377
38378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38379   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38380
38381   arg1 = (Dali::Stage *)jarg1;
38382   {
38383     try {
38384       delete arg1;
38385     } catch (std::out_of_range& e) {
38386       {
38387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38388       };
38389     } catch (std::exception& e) {
38390       {
38391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38392       };
38393     } catch (Dali::DaliException e) {
38394       {
38395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38396       };
38397     } catch (...) {
38398       {
38399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38400       };
38401     }
38402   }
38403
38404 }
38405
38406
38407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38408   void * jresult ;
38409   Dali::Stage *arg1 = 0 ;
38410   Dali::Stage *result = 0 ;
38411
38412   arg1 = (Dali::Stage *)jarg1;
38413   if (!arg1) {
38414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38415     return 0;
38416   }
38417   {
38418     try {
38419       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
38445   void * jresult ;
38446   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38447   Dali::Stage *arg2 = 0 ;
38448   Dali::Stage *result = 0 ;
38449
38450   arg1 = (Dali::Stage *)jarg1;
38451   arg2 = (Dali::Stage *)jarg2;
38452   if (!arg2) {
38453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38454     return 0;
38455   }
38456   {
38457     try {
38458       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38459     } catch (std::out_of_range& e) {
38460       {
38461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38462       };
38463     } catch (std::exception& e) {
38464       {
38465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38466       };
38467     } catch (Dali::DaliException e) {
38468       {
38469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38470       };
38471     } catch (...) {
38472       {
38473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38474       };
38475     }
38476   }
38477
38478   jresult = (void *)result;
38479   return jresult;
38480 }
38481
38482
38483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38484   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38485   Dali::Actor *arg2 = 0 ;
38486
38487   arg1 = (Dali::Stage *)jarg1;
38488   arg2 = (Dali::Actor *)jarg2;
38489   if (!arg2) {
38490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38491     return ;
38492   }
38493   {
38494     try {
38495       (arg1)->Add(*arg2);
38496     } catch (std::out_of_range& e) {
38497       {
38498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38499       };
38500     } catch (std::exception& e) {
38501       {
38502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38503       };
38504     } catch (Dali::DaliException e) {
38505       {
38506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38507       };
38508     } catch (...) {
38509       {
38510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38511       };
38512     }
38513   }
38514
38515 }
38516
38517
38518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38519   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38520   Dali::Actor *arg2 = 0 ;
38521
38522   arg1 = (Dali::Stage *)jarg1;
38523   arg2 = (Dali::Actor *)jarg2;
38524   if (!arg2) {
38525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38526     return ;
38527   }
38528   {
38529     try {
38530       (arg1)->Remove(*arg2);
38531     } catch (std::out_of_range& e) {
38532       {
38533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38534       };
38535     } catch (std::exception& e) {
38536       {
38537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38538       };
38539     } catch (Dali::DaliException e) {
38540       {
38541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38542       };
38543     } catch (...) {
38544       {
38545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38546       };
38547     }
38548   }
38549
38550 }
38551
38552
38553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38554   void * jresult ;
38555   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38556   Dali::Vector2 result;
38557
38558   arg1 = (Dali::Stage *)jarg1;
38559   {
38560     try {
38561       result = ((Dali::Stage const *)arg1)->GetSize();
38562     } catch (std::out_of_range& e) {
38563       {
38564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38565       };
38566     } catch (std::exception& e) {
38567       {
38568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38569       };
38570     } catch (Dali::DaliException e) {
38571       {
38572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38573       };
38574     } catch (...) {
38575       {
38576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38577       };
38578     }
38579   }
38580
38581   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38582   return jresult;
38583 }
38584
38585
38586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38587   void * jresult ;
38588   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38589   Dali::RenderTaskList result;
38590
38591   arg1 = (Dali::Stage *)jarg1;
38592   {
38593     try {
38594       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38595     } catch (std::out_of_range& e) {
38596       {
38597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38598       };
38599     } catch (std::exception& e) {
38600       {
38601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38602       };
38603     } catch (Dali::DaliException e) {
38604       {
38605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38606       };
38607     } catch (...) {
38608       {
38609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38610       };
38611     }
38612   }
38613
38614   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38615   return jresult;
38616 }
38617
38618
38619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38620   unsigned int jresult ;
38621   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38622   unsigned int result;
38623
38624   arg1 = (Dali::Stage *)jarg1;
38625   {
38626     try {
38627       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38628     } catch (std::out_of_range& e) {
38629       {
38630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38631       };
38632     } catch (std::exception& e) {
38633       {
38634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38635       };
38636     } catch (Dali::DaliException e) {
38637       {
38638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38639       };
38640     } catch (...) {
38641       {
38642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38643       };
38644     }
38645   }
38646
38647   jresult = result;
38648   return jresult;
38649 }
38650
38651
38652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38653   void * jresult ;
38654   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38655   unsigned int arg2 ;
38656   Dali::Layer result;
38657
38658   arg1 = (Dali::Stage *)jarg1;
38659   arg2 = (unsigned int)jarg2;
38660   {
38661     try {
38662       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38663     } catch (std::out_of_range& e) {
38664       {
38665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38666       };
38667     } catch (std::exception& e) {
38668       {
38669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38670       };
38671     } catch (Dali::DaliException e) {
38672       {
38673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38674       };
38675     } catch (...) {
38676       {
38677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38678       };
38679     }
38680   }
38681
38682   jresult = new Dali::Layer((const Dali::Layer &)result);
38683   return jresult;
38684 }
38685
38686
38687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38688   void * jresult ;
38689   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38690   Dali::Layer result;
38691
38692   arg1 = (Dali::Stage *)jarg1;
38693   {
38694     try {
38695       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38696     } catch (std::out_of_range& e) {
38697       {
38698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38699       };
38700     } catch (std::exception& e) {
38701       {
38702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38703       };
38704     } catch (Dali::DaliException e) {
38705       {
38706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38707       };
38708     } catch (...) {
38709       {
38710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38711       };
38712     }
38713   }
38714
38715   jresult = new Dali::Layer((const Dali::Layer &)result);
38716   return jresult;
38717 }
38718
38719
38720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38721   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38722   Dali::Vector4 arg2 ;
38723   Dali::Vector4 *argp2 ;
38724
38725   arg1 = (Dali::Stage *)jarg1;
38726   argp2 = (Dali::Vector4 *)jarg2;
38727   if (!argp2) {
38728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38729     return ;
38730   }
38731   arg2 = *argp2;
38732   {
38733     try {
38734       (arg1)->SetBackgroundColor(arg2);
38735     } catch (std::out_of_range& e) {
38736       {
38737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38738       };
38739     } catch (std::exception& e) {
38740       {
38741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38742       };
38743     } catch (Dali::DaliException e) {
38744       {
38745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38746       };
38747     } catch (...) {
38748       {
38749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38750       };
38751     }
38752   }
38753
38754 }
38755
38756
38757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38758   void * jresult ;
38759   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38760   Dali::Vector4 result;
38761
38762   arg1 = (Dali::Stage *)jarg1;
38763   {
38764     try {
38765       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38766     } catch (std::out_of_range& e) {
38767       {
38768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38769       };
38770     } catch (std::exception& e) {
38771       {
38772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38773       };
38774     } catch (Dali::DaliException e) {
38775       {
38776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38777       };
38778     } catch (...) {
38779       {
38780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38781       };
38782     }
38783   }
38784
38785   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38786   return jresult;
38787 }
38788
38789
38790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38791   void * jresult ;
38792   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38793   Dali::Vector2 result;
38794
38795   arg1 = (Dali::Stage *)jarg1;
38796   {
38797     try {
38798       result = ((Dali::Stage const *)arg1)->GetDpi();
38799     } catch (std::out_of_range& e) {
38800       {
38801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38802       };
38803     } catch (std::exception& e) {
38804       {
38805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38806       };
38807     } catch (Dali::DaliException e) {
38808       {
38809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38810       };
38811     } catch (...) {
38812       {
38813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38814       };
38815     }
38816   }
38817
38818   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38819   return jresult;
38820 }
38821
38822
38823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38824   void * jresult ;
38825   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38826   Dali::ObjectRegistry result;
38827
38828   arg1 = (Dali::Stage *)jarg1;
38829   {
38830     try {
38831       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38832     } catch (std::out_of_range& e) {
38833       {
38834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38835       };
38836     } catch (std::exception& e) {
38837       {
38838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38839       };
38840     } catch (Dali::DaliException e) {
38841       {
38842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38843       };
38844     } catch (...) {
38845       {
38846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38847       };
38848     }
38849   }
38850
38851   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38852   return jresult;
38853 }
38854
38855
38856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38857   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38858   float arg2 ;
38859
38860   arg1 = (Dali::Stage *)jarg1;
38861   arg2 = (float)jarg2;
38862   {
38863     try {
38864       (arg1)->KeepRendering(arg2);
38865     } catch (std::out_of_range& e) {
38866       {
38867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38868       };
38869     } catch (std::exception& e) {
38870       {
38871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38872       };
38873     } catch (Dali::DaliException e) {
38874       {
38875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38876       };
38877     } catch (...) {
38878       {
38879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38880       };
38881     }
38882   }
38883
38884 }
38885
38886
38887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38888   void * jresult ;
38889   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38890   Dali::Stage::KeyEventSignalType *result = 0 ;
38891
38892   arg1 = (Dali::Stage *)jarg1;
38893   {
38894     try {
38895       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38896     } catch (std::out_of_range& e) {
38897       {
38898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38899       };
38900     } catch (std::exception& e) {
38901       {
38902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38903       };
38904     } catch (Dali::DaliException e) {
38905       {
38906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38907       };
38908     } catch (...) {
38909       {
38910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38911       };
38912     }
38913   }
38914
38915   jresult = (void *)result;
38916   return jresult;
38917 }
38918
38919
38920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38921   void * jresult ;
38922   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38923   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38924
38925   arg1 = (Dali::Stage *)jarg1;
38926   {
38927     try {
38928       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38929     } catch (std::out_of_range& e) {
38930       {
38931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38932       };
38933     } catch (std::exception& e) {
38934       {
38935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38936       };
38937     } catch (Dali::DaliException e) {
38938       {
38939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38940       };
38941     } catch (...) {
38942       {
38943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38944       };
38945     }
38946   }
38947
38948   jresult = (void *)result;
38949   return jresult;
38950 }
38951
38952
38953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38954   void * jresult ;
38955   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38956   Dali::Stage::TouchSignalType *result = 0 ;
38957
38958   arg1 = (Dali::Stage *)jarg1;
38959   {
38960     try {
38961       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38962     } catch (std::out_of_range& e) {
38963       {
38964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38965       };
38966     } catch (std::exception& e) {
38967       {
38968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38969       };
38970     } catch (Dali::DaliException e) {
38971       {
38972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38973       };
38974     } catch (...) {
38975       {
38976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38977       };
38978     }
38979   }
38980
38981   jresult = (void *)result;
38982   return jresult;
38983 }
38984
38985
38986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38987   void * jresult ;
38988   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38989   Dali::Stage::WheelEventSignalType *result = 0 ;
38990
38991   arg1 = (Dali::Stage *)jarg1;
38992   {
38993     try {
38994       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38995     } catch (std::out_of_range& e) {
38996       {
38997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38998       };
38999     } catch (std::exception& e) {
39000       {
39001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39002       };
39003     } catch (Dali::DaliException e) {
39004       {
39005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39006       };
39007     } catch (...) {
39008       {
39009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39010       };
39011     }
39012   }
39013
39014   jresult = (void *)result;
39015   return jresult;
39016 }
39017
39018
39019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39020   void * jresult ;
39021   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39022   Dali::Stage::ContextStatusSignal *result = 0 ;
39023
39024   arg1 = (Dali::Stage *)jarg1;
39025   {
39026     try {
39027       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39028     } catch (std::out_of_range& e) {
39029       {
39030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39031       };
39032     } catch (std::exception& e) {
39033       {
39034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39035       };
39036     } catch (Dali::DaliException e) {
39037       {
39038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39039       };
39040     } catch (...) {
39041       {
39042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39043       };
39044     }
39045   }
39046
39047   jresult = (void *)result;
39048   return jresult;
39049 }
39050
39051
39052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39053   void * jresult ;
39054   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39055   Dali::Stage::ContextStatusSignal *result = 0 ;
39056
39057   arg1 = (Dali::Stage *)jarg1;
39058   {
39059     try {
39060       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39061     } catch (std::out_of_range& e) {
39062       {
39063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39064       };
39065     } catch (std::exception& e) {
39066       {
39067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39068       };
39069     } catch (Dali::DaliException e) {
39070       {
39071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39072       };
39073     } catch (...) {
39074       {
39075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39076       };
39077     }
39078   }
39079
39080   jresult = (void *)result;
39081   return jresult;
39082 }
39083
39084
39085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39086   void * jresult ;
39087   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39088   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39089
39090   arg1 = (Dali::Stage *)jarg1;
39091   {
39092     try {
39093       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39094     } catch (std::out_of_range& e) {
39095       {
39096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39097       };
39098     } catch (std::exception& e) {
39099       {
39100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39101       };
39102     } catch (Dali::DaliException e) {
39103       {
39104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39105       };
39106     } catch (...) {
39107       {
39108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39109       };
39110     }
39111   }
39112
39113   jresult = (void *)result;
39114   return jresult;
39115 }
39116
39117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39118   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39119   Dali::DevelStage::Rendering arg2 ;
39120
39121   arg1 = (Dali::Stage *)jarg1;
39122   arg2 = (Dali::DevelStage::Rendering)jarg2;
39123   {
39124     try {
39125       DevelStage::SetRenderingBehavior(*arg1,arg2);
39126     } catch (std::out_of_range& e) {
39127       {
39128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39129       };
39130     } catch (std::exception& e) {
39131       {
39132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39133       };
39134     } catch (Dali::DaliException e) {
39135       {
39136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39137       };
39138     } catch (...) {
39139       {
39140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39141       };
39142     }
39143   }
39144
39145 }
39146
39147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39148
39149   int jresult ;
39150   int result ;
39151   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39152
39153   arg1 = (Dali::Stage *)jarg1;
39154   {
39155     try {
39156       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39157     } catch (std::out_of_range& e) {
39158       {
39159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39160       };
39161     } catch (std::exception& e) {
39162       {
39163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39164       };
39165     } catch (Dali::DaliException e) {
39166       {
39167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39168       };
39169     } catch (...) {
39170       {
39171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39172       };
39173     }
39174   }
39175
39176   jresult = result;
39177   return jresult;
39178 }
39179
39180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39181   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39182
39183   arg1 = (Dali::RelayoutContainer *)jarg1;
39184   {
39185     try {
39186       delete arg1;
39187     } catch (std::out_of_range& e) {
39188       {
39189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39190       };
39191     } catch (std::exception& e) {
39192       {
39193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39194       };
39195     } catch (Dali::DaliException e) {
39196       {
39197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39198       };
39199     } catch (...) {
39200       {
39201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39202       };
39203     }
39204   }
39205
39206 }
39207
39208
39209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39210   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39211   Dali::Actor *arg2 = 0 ;
39212   Dali::Vector2 *arg3 = 0 ;
39213
39214   arg1 = (Dali::RelayoutContainer *)jarg1;
39215   arg2 = (Dali::Actor *)jarg2;
39216   if (!arg2) {
39217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39218     return ;
39219   }
39220   arg3 = (Dali::Vector2 *)jarg3;
39221   if (!arg3) {
39222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39223     return ;
39224   }
39225   {
39226     try {
39227       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39228     } catch (std::out_of_range& e) {
39229       {
39230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39231       };
39232     } catch (std::exception& e) {
39233       {
39234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39235       };
39236     } catch (Dali::DaliException e) {
39237       {
39238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39239       };
39240     } catch (...) {
39241       {
39242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39243       };
39244     }
39245   }
39246
39247 }
39248
39249
39250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39251   void * jresult ;
39252   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39253   Dali::CustomActor result;
39254
39255   arg1 = (Dali::CustomActorImpl *)jarg1;
39256   {
39257     try {
39258       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39259     } catch (std::out_of_range& e) {
39260       {
39261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39262       };
39263     } catch (std::exception& e) {
39264       {
39265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39266       };
39267     } catch (Dali::DaliException e) {
39268       {
39269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39270       };
39271     } catch (...) {
39272       {
39273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39274       };
39275     }
39276   }
39277
39278   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39279   return jresult;
39280 }
39281
39282
39283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39284   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39285   int arg2 ;
39286
39287   arg1 = (Dali::CustomActorImpl *)jarg1;
39288   arg2 = (int)jarg2;
39289   {
39290     try {
39291       (arg1)->OnStageConnection(arg2);
39292     } catch (std::out_of_range& e) {
39293       {
39294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39295       };
39296     } catch (std::exception& e) {
39297       {
39298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39299       };
39300     } catch (Dali::DaliException e) {
39301       {
39302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39303       };
39304     } catch (...) {
39305       {
39306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39307       };
39308     }
39309   }
39310
39311 }
39312
39313
39314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39315   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39316
39317   arg1 = (Dali::CustomActorImpl *)jarg1;
39318   {
39319     try {
39320       (arg1)->OnStageDisconnection();
39321     } catch (std::out_of_range& e) {
39322       {
39323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39324       };
39325     } catch (std::exception& e) {
39326       {
39327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39328       };
39329     } catch (Dali::DaliException e) {
39330       {
39331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39332       };
39333     } catch (...) {
39334       {
39335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39336       };
39337     }
39338   }
39339
39340 }
39341
39342
39343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39344   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39345   Dali::Actor *arg2 = 0 ;
39346
39347   arg1 = (Dali::CustomActorImpl *)jarg1;
39348   arg2 = (Dali::Actor *)jarg2;
39349   if (!arg2) {
39350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39351     return ;
39352   }
39353   {
39354     try {
39355       (arg1)->OnChildAdd(*arg2);
39356     } catch (std::out_of_range& e) {
39357       {
39358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39359       };
39360     } catch (std::exception& e) {
39361       {
39362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39363       };
39364     } catch (Dali::DaliException e) {
39365       {
39366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39367       };
39368     } catch (...) {
39369       {
39370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39371       };
39372     }
39373   }
39374
39375 }
39376
39377
39378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39379   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39380   Dali::Actor *arg2 = 0 ;
39381
39382   arg1 = (Dali::CustomActorImpl *)jarg1;
39383   arg2 = (Dali::Actor *)jarg2;
39384   if (!arg2) {
39385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39386     return ;
39387   }
39388   {
39389     try {
39390       (arg1)->OnChildRemove(*arg2);
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_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39414   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39415   Dali::Property::Index arg2 ;
39416   Dali::Property::Value arg3 ;
39417   Dali::Property::Value *argp3 ;
39418
39419   arg1 = (Dali::CustomActorImpl *)jarg1;
39420   arg2 = (Dali::Property::Index)jarg2;
39421   argp3 = (Dali::Property::Value *)jarg3;
39422   if (!argp3) {
39423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39424     return ;
39425   }
39426   arg3 = *argp3;
39427   {
39428     try {
39429       (arg1)->OnPropertySet(arg2,arg3);
39430     } catch (std::out_of_range& e) {
39431       {
39432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39433       };
39434     } catch (std::exception& e) {
39435       {
39436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39437       };
39438     } catch (Dali::DaliException e) {
39439       {
39440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39441       };
39442     } catch (...) {
39443       {
39444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39445       };
39446     }
39447   }
39448
39449 }
39450
39451
39452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39453   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39454   Dali::Vector3 *arg2 = 0 ;
39455
39456   arg1 = (Dali::CustomActorImpl *)jarg1;
39457   arg2 = (Dali::Vector3 *)jarg2;
39458   if (!arg2) {
39459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39460     return ;
39461   }
39462   {
39463     try {
39464       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39465     } catch (std::out_of_range& e) {
39466       {
39467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39468       };
39469     } catch (std::exception& e) {
39470       {
39471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39472       };
39473     } catch (Dali::DaliException e) {
39474       {
39475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39476       };
39477     } catch (...) {
39478       {
39479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39480       };
39481     }
39482   }
39483
39484 }
39485
39486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39487   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39488   Dali::Animation *arg2 = 0 ;
39489   Dali::Vector3 *arg3 = 0 ;
39490
39491   arg1 = (Dali::CustomActorImpl *)jarg1;
39492   arg2 = (Dali::Animation *)jarg2;
39493   if (!arg2) {
39494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39495     return ;
39496   }
39497   arg3 = (Dali::Vector3 *)jarg3;
39498   if (!arg3) {
39499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39500     return ;
39501   }
39502   {
39503     try {
39504       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39505     } catch (std::out_of_range& e) {
39506       {
39507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39508       };
39509     } catch (std::exception& e) {
39510       {
39511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39512       };
39513     } catch (Dali::DaliException e) {
39514       {
39515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39516       };
39517     } catch (...) {
39518       {
39519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39520       };
39521     }
39522   }
39523
39524 }
39525
39526
39527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39528   unsigned int jresult ;
39529   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39530   Dali::TouchEvent *arg2 = 0 ;
39531   bool result;
39532
39533   arg1 = (Dali::CustomActorImpl *)jarg1;
39534   arg2 = (Dali::TouchEvent *)jarg2;
39535   if (!arg2) {
39536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39537     return 0;
39538   }
39539   {
39540     try {
39541       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent 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_OnHoverEvent(void * jarg1, void * jarg2) {
39567   unsigned int jresult ;
39568   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39569   Dali::HoverEvent *arg2 = 0 ;
39570   bool result;
39571
39572   arg1 = (Dali::CustomActorImpl *)jarg1;
39573   arg2 = (Dali::HoverEvent *)jarg2;
39574   if (!arg2) {
39575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39576     return 0;
39577   }
39578   {
39579     try {
39580       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent 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_OnKeyEvent(void * jarg1, void * jarg2) {
39606   unsigned int jresult ;
39607   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39608   Dali::KeyEvent *arg2 = 0 ;
39609   bool result;
39610
39611   arg1 = (Dali::CustomActorImpl *)jarg1;
39612   arg2 = (Dali::KeyEvent *)jarg2;
39613   if (!arg2) {
39614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39615     return 0;
39616   }
39617   {
39618     try {
39619       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent 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 unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39645   unsigned int jresult ;
39646   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39647   Dali::WheelEvent *arg2 = 0 ;
39648   bool result;
39649
39650   arg1 = (Dali::CustomActorImpl *)jarg1;
39651   arg2 = (Dali::WheelEvent *)jarg2;
39652   if (!arg2) {
39653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39654     return 0;
39655   }
39656   {
39657     try {
39658       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39659     } catch (std::out_of_range& e) {
39660       {
39661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39662       };
39663     } catch (std::exception& e) {
39664       {
39665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39666       };
39667     } catch (Dali::DaliException e) {
39668       {
39669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39670       };
39671     } catch (...) {
39672       {
39673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39674       };
39675     }
39676   }
39677
39678   jresult = result;
39679   return jresult;
39680 }
39681
39682
39683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39684   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39685   Dali::Vector2 *arg2 = 0 ;
39686   Dali::RelayoutContainer *arg3 = 0 ;
39687
39688   arg1 = (Dali::CustomActorImpl *)jarg1;
39689   arg2 = (Dali::Vector2 *)jarg2;
39690   if (!arg2) {
39691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39692     return ;
39693   }
39694   arg3 = (Dali::RelayoutContainer *)jarg3;
39695   if (!arg3) {
39696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39697     return ;
39698   }
39699   {
39700     try {
39701       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39702     } catch (std::out_of_range& e) {
39703       {
39704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39705       };
39706     } catch (std::exception& e) {
39707       {
39708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39709       };
39710     } catch (Dali::DaliException e) {
39711       {
39712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39713       };
39714     } catch (...) {
39715       {
39716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39717       };
39718     }
39719   }
39720
39721 }
39722
39723
39724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39725   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39726   Dali::ResizePolicy::Type arg2 ;
39727   Dali::Dimension::Type arg3 ;
39728
39729   arg1 = (Dali::CustomActorImpl *)jarg1;
39730   arg2 = (Dali::ResizePolicy::Type)jarg2;
39731   arg3 = (Dali::Dimension::Type)jarg3;
39732   {
39733     try {
39734       (arg1)->OnSetResizePolicy(arg2,arg3);
39735     } catch (std::out_of_range& e) {
39736       {
39737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39738       };
39739     } catch (std::exception& e) {
39740       {
39741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39742       };
39743     } catch (Dali::DaliException e) {
39744       {
39745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39746       };
39747     } catch (...) {
39748       {
39749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39750       };
39751     }
39752   }
39753
39754 }
39755
39756
39757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39758   void * jresult ;
39759   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39760   Dali::Vector3 result;
39761
39762   arg1 = (Dali::CustomActorImpl *)jarg1;
39763   {
39764     try {
39765       result = (arg1)->GetNaturalSize();
39766     } catch (std::out_of_range& e) {
39767       {
39768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39769       };
39770     } catch (std::exception& e) {
39771       {
39772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39773       };
39774     } catch (Dali::DaliException e) {
39775       {
39776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39777       };
39778     } catch (...) {
39779       {
39780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39781       };
39782     }
39783   }
39784
39785   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39786   return jresult;
39787 }
39788
39789
39790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39791   float jresult ;
39792   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39793   Dali::Actor *arg2 = 0 ;
39794   Dali::Dimension::Type arg3 ;
39795   float result;
39796
39797   arg1 = (Dali::CustomActorImpl *)jarg1;
39798   arg2 = (Dali::Actor *)jarg2;
39799   if (!arg2) {
39800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39801     return 0;
39802   }
39803   arg3 = (Dali::Dimension::Type)jarg3;
39804   {
39805     try {
39806       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39807     } catch (std::out_of_range& e) {
39808       {
39809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39810       };
39811     } catch (std::exception& e) {
39812       {
39813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39814       };
39815     } catch (Dali::DaliException e) {
39816       {
39817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39818       };
39819     } catch (...) {
39820       {
39821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39822       };
39823     }
39824   }
39825
39826   jresult = result;
39827   return jresult;
39828 }
39829
39830
39831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39832   float jresult ;
39833   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39834   float arg2 ;
39835   float result;
39836
39837   arg1 = (Dali::CustomActorImpl *)jarg1;
39838   arg2 = (float)jarg2;
39839   {
39840     try {
39841       result = (float)(arg1)->GetHeightForWidth(arg2);
39842     } catch (std::out_of_range& e) {
39843       {
39844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39845       };
39846     } catch (std::exception& e) {
39847       {
39848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39849       };
39850     } catch (Dali::DaliException e) {
39851       {
39852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39853       };
39854     } catch (...) {
39855       {
39856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39857       };
39858     }
39859   }
39860
39861   jresult = result;
39862   return jresult;
39863 }
39864
39865
39866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39867   float jresult ;
39868   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39869   float arg2 ;
39870   float result;
39871
39872   arg1 = (Dali::CustomActorImpl *)jarg1;
39873   arg2 = (float)jarg2;
39874   {
39875     try {
39876       result = (float)(arg1)->GetWidthForHeight(arg2);
39877     } catch (std::out_of_range& e) {
39878       {
39879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39880       };
39881     } catch (std::exception& e) {
39882       {
39883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39884       };
39885     } catch (Dali::DaliException e) {
39886       {
39887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39888       };
39889     } catch (...) {
39890       {
39891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39892       };
39893     }
39894   }
39895
39896   jresult = result;
39897   return jresult;
39898 }
39899
39900
39901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39902   unsigned int jresult ;
39903   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39904   Dali::Dimension::Type arg2 ;
39905   bool result;
39906
39907   arg1 = (Dali::CustomActorImpl *)jarg1;
39908   arg2 = (Dali::Dimension::Type)jarg2;
39909   {
39910     try {
39911       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39912     } catch (std::out_of_range& e) {
39913       {
39914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39915       };
39916     } catch (std::exception& e) {
39917       {
39918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39919       };
39920     } catch (Dali::DaliException e) {
39921       {
39922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39923       };
39924     } catch (...) {
39925       {
39926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39927       };
39928     }
39929   }
39930
39931   jresult = result;
39932   return jresult;
39933 }
39934
39935
39936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39937   unsigned int jresult ;
39938   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39939   bool result;
39940
39941   arg1 = (Dali::CustomActorImpl *)jarg1;
39942   {
39943     try {
39944       result = (bool)(arg1)->RelayoutDependentOnChildren();
39945     } catch (std::out_of_range& e) {
39946       {
39947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39948       };
39949     } catch (std::exception& e) {
39950       {
39951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39952       };
39953     } catch (Dali::DaliException e) {
39954       {
39955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39956       };
39957     } catch (...) {
39958       {
39959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39960       };
39961     }
39962   }
39963
39964   jresult = result;
39965   return jresult;
39966 }
39967
39968
39969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39970   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39971   Dali::Dimension::Type arg2 ;
39972
39973   arg1 = (Dali::CustomActorImpl *)jarg1;
39974   arg2 = (Dali::Dimension::Type)jarg2;
39975   {
39976     try {
39977       (arg1)->OnCalculateRelayoutSize(arg2);
39978     } catch (std::out_of_range& e) {
39979       {
39980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39981       };
39982     } catch (std::exception& e) {
39983       {
39984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39985       };
39986     } catch (Dali::DaliException e) {
39987       {
39988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39989       };
39990     } catch (...) {
39991       {
39992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39993       };
39994     }
39995   }
39996
39997 }
39998
39999
40000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40001   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40002   float arg2 ;
40003   Dali::Dimension::Type arg3 ;
40004
40005   arg1 = (Dali::CustomActorImpl *)jarg1;
40006   arg2 = (float)jarg2;
40007   arg3 = (Dali::Dimension::Type)jarg3;
40008   {
40009     try {
40010       (arg1)->OnLayoutNegotiated(arg2,arg3);
40011     } catch (std::out_of_range& e) {
40012       {
40013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40014       };
40015     } catch (std::exception& e) {
40016       {
40017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40018       };
40019     } catch (Dali::DaliException e) {
40020       {
40021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40022       };
40023     } catch (...) {
40024       {
40025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40026       };
40027     }
40028   }
40029
40030 }
40031
40032
40033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40034   unsigned int jresult ;
40035   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40036   bool result;
40037
40038   arg1 = (Dali::CustomActorImpl *)jarg1;
40039   {
40040     try {
40041       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40042     } catch (std::out_of_range& e) {
40043       {
40044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40045       };
40046     } catch (std::exception& e) {
40047       {
40048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40049       };
40050     } catch (Dali::DaliException e) {
40051       {
40052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40053       };
40054     } catch (...) {
40055       {
40056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40057       };
40058     }
40059   }
40060
40061   jresult = result;
40062   return jresult;
40063 }
40064
40065
40066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40067   unsigned int jresult ;
40068   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40069   bool result;
40070
40071   arg1 = (Dali::CustomActorImpl *)jarg1;
40072   {
40073     try {
40074       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40075     } catch (std::out_of_range& e) {
40076       {
40077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40078       };
40079     } catch (std::exception& e) {
40080       {
40081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40082       };
40083     } catch (Dali::DaliException e) {
40084       {
40085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40086       };
40087     } catch (...) {
40088       {
40089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40090       };
40091     }
40092   }
40093
40094   jresult = result;
40095   return jresult;
40096 }
40097
40098
40099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40100   unsigned int jresult ;
40101   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40102   bool result;
40103
40104   arg1 = (Dali::CustomActorImpl *)jarg1;
40105   {
40106     try {
40107       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40108     } catch (std::out_of_range& e) {
40109       {
40110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40111       };
40112     } catch (std::exception& e) {
40113       {
40114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40115       };
40116     } catch (Dali::DaliException e) {
40117       {
40118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40119       };
40120     } catch (...) {
40121       {
40122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40123       };
40124     }
40125   }
40126
40127   jresult = result;
40128   return jresult;
40129 }
40130
40131
40132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40133   unsigned int jresult ;
40134   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40135   bool result;
40136
40137   arg1 = (Dali::CustomActorImpl *)jarg1;
40138   {
40139     try {
40140       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40141     } catch (std::out_of_range& e) {
40142       {
40143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40144       };
40145     } catch (std::exception& e) {
40146       {
40147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40148       };
40149     } catch (Dali::DaliException e) {
40150       {
40151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40152       };
40153     } catch (...) {
40154       {
40155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40156       };
40157     }
40158   }
40159
40160   jresult = result;
40161   return jresult;
40162 }
40163
40164
40165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40166   void * jresult ;
40167   Dali::CustomActor *result = 0 ;
40168
40169   {
40170     try {
40171       result = (Dali::CustomActor *)new Dali::CustomActor();
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 = (void *)result;
40192   return jresult;
40193 }
40194
40195
40196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40197   void * jresult ;
40198   Dali::BaseHandle arg1 ;
40199   Dali::BaseHandle *argp1 ;
40200   Dali::CustomActor result;
40201
40202   argp1 = (Dali::BaseHandle *)jarg1;
40203   if (!argp1) {
40204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40205     return 0;
40206   }
40207   arg1 = *argp1;
40208   {
40209     try {
40210       result = Dali::CustomActor::DownCast(arg1);
40211     } catch (std::out_of_range& e) {
40212       {
40213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40214       };
40215     } catch (std::exception& e) {
40216       {
40217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40218       };
40219     } catch (Dali::DaliException e) {
40220       {
40221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40222       };
40223     } catch (...) {
40224       {
40225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40226       };
40227     }
40228   }
40229
40230   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40231   return jresult;
40232 }
40233
40234
40235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40236   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40237
40238   arg1 = (Dali::CustomActor *)jarg1;
40239   {
40240     try {
40241       delete arg1;
40242     } catch (std::out_of_range& e) {
40243       {
40244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40245       };
40246     } catch (std::exception& e) {
40247       {
40248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40249       };
40250     } catch (Dali::DaliException e) {
40251       {
40252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40253       };
40254     } catch (...) {
40255       {
40256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40257       };
40258     }
40259   }
40260
40261 }
40262
40263
40264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40265   void * jresult ;
40266   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40267   Dali::CustomActorImpl *result = 0 ;
40268
40269   arg1 = (Dali::CustomActor *)jarg1;
40270   {
40271     try {
40272       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40273     } catch (std::out_of_range& e) {
40274       {
40275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40276       };
40277     } catch (std::exception& e) {
40278       {
40279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40280       };
40281     } catch (Dali::DaliException e) {
40282       {
40283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40284       };
40285     } catch (...) {
40286       {
40287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40288       };
40289     }
40290   }
40291
40292   jresult = (void *)result;
40293   return jresult;
40294 }
40295
40296
40297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40298   void * jresult ;
40299   Dali::CustomActorImpl *arg1 = 0 ;
40300   Dali::CustomActor *result = 0 ;
40301
40302   arg1 = (Dali::CustomActorImpl *)jarg1;
40303   if (!arg1) {
40304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40305     return 0;
40306   }
40307   {
40308     try {
40309       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40310     } catch (std::out_of_range& e) {
40311       {
40312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40313       };
40314     } catch (std::exception& e) {
40315       {
40316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40317       };
40318     } catch (Dali::DaliException e) {
40319       {
40320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40321       };
40322     } catch (...) {
40323       {
40324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40325       };
40326     }
40327   }
40328
40329   jresult = (void *)result;
40330   return jresult;
40331 }
40332
40333
40334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40335   void * jresult ;
40336   Dali::CustomActor *arg1 = 0 ;
40337   Dali::CustomActor *result = 0 ;
40338
40339   arg1 = (Dali::CustomActor *)jarg1;
40340   if (!arg1) {
40341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40342     return 0;
40343   }
40344   {
40345     try {
40346       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
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 void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40372   void * jresult ;
40373   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40374   Dali::CustomActor *arg2 = 0 ;
40375   Dali::CustomActor *result = 0 ;
40376
40377   arg1 = (Dali::CustomActor *)jarg1;
40378   arg2 = (Dali::CustomActor *)jarg2;
40379   if (!arg2) {
40380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40381     return 0;
40382   }
40383   {
40384     try {
40385       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40386     } catch (std::out_of_range& e) {
40387       {
40388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40389       };
40390     } catch (std::exception& e) {
40391       {
40392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40393       };
40394     } catch (Dali::DaliException e) {
40395       {
40396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40397       };
40398     } catch (...) {
40399       {
40400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40401       };
40402     }
40403   }
40404
40405   jresult = (void *)result;
40406   return jresult;
40407 }
40408
40409
40410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40411   int jresult ;
40412   int result;
40413
40414   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40415   jresult = (int)result;
40416   return jresult;
40417 }
40418
40419
40420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40421   int jresult ;
40422   int result;
40423
40424   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40425   jresult = (int)result;
40426   return jresult;
40427 }
40428
40429
40430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40431   int jresult ;
40432   int result;
40433
40434   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40435   jresult = (int)result;
40436   return jresult;
40437 }
40438
40439
40440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40441   int jresult ;
40442   int result;
40443
40444   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40445   jresult = (int)result;
40446   return jresult;
40447 }
40448
40449
40450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40451   int jresult ;
40452   int result;
40453
40454   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40455   jresult = (int)result;
40456   return jresult;
40457 }
40458
40459
40460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40461   int jresult ;
40462   int result;
40463
40464   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40465   jresult = (int)result;
40466   return jresult;
40467 }
40468
40469
40470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40471   int jresult ;
40472   int result;
40473
40474   result = (int)Dali::PanGestureDetector::Property::PANNING;
40475   jresult = (int)result;
40476   return jresult;
40477 }
40478
40479
40480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40481   void * jresult ;
40482   Dali::PanGestureDetector::Property *result = 0 ;
40483
40484   {
40485     try {
40486       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40487     } catch (std::out_of_range& e) {
40488       {
40489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40490       };
40491     } catch (std::exception& e) {
40492       {
40493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40494       };
40495     } catch (Dali::DaliException e) {
40496       {
40497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40498       };
40499     } catch (...) {
40500       {
40501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40502       };
40503     }
40504   }
40505
40506   jresult = (void *)result;
40507   return jresult;
40508 }
40509
40510
40511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40512   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40513
40514   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40515   {
40516     try {
40517       delete arg1;
40518     } catch (std::out_of_range& e) {
40519       {
40520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40521       };
40522     } catch (std::exception& e) {
40523       {
40524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40525       };
40526     } catch (Dali::DaliException e) {
40527       {
40528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40529       };
40530     } catch (...) {
40531       {
40532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40533       };
40534     }
40535   }
40536
40537 }
40538
40539
40540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40541   void * jresult ;
40542   Dali::Radian *result = 0 ;
40543
40544   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40545   jresult = (void *)result;
40546   return jresult;
40547 }
40548
40549
40550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40551   void * jresult ;
40552   Dali::Radian *result = 0 ;
40553
40554   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40555   jresult = (void *)result;
40556   return jresult;
40557 }
40558
40559
40560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40561   void * jresult ;
40562   Dali::Radian *result = 0 ;
40563
40564   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40565   jresult = (void *)result;
40566   return jresult;
40567 }
40568
40569
40570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40571   void * jresult ;
40572   Dali::Radian *result = 0 ;
40573
40574   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40575   jresult = (void *)result;
40576   return jresult;
40577 }
40578
40579
40580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40581   void * jresult ;
40582   Dali::Radian *result = 0 ;
40583
40584   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40585   jresult = (void *)result;
40586   return jresult;
40587 }
40588
40589
40590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40591   void * jresult ;
40592   Dali::Radian *result = 0 ;
40593
40594   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40595   jresult = (void *)result;
40596   return jresult;
40597 }
40598
40599
40600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40601   void * jresult ;
40602   Dali::Radian *result = 0 ;
40603
40604   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40605   jresult = (void *)result;
40606   return jresult;
40607 }
40608
40609
40610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40611   void * jresult ;
40612   Dali::PanGestureDetector *result = 0 ;
40613
40614   {
40615     try {
40616       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40617     } catch (std::out_of_range& e) {
40618       {
40619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40620       };
40621     } catch (std::exception& e) {
40622       {
40623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40624       };
40625     } catch (Dali::DaliException e) {
40626       {
40627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40628       };
40629     } catch (...) {
40630       {
40631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40632       };
40633     }
40634   }
40635
40636   jresult = (void *)result;
40637   return jresult;
40638 }
40639
40640
40641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40642   void * jresult ;
40643   Dali::PanGestureDetector result;
40644
40645   {
40646     try {
40647       result = Dali::PanGestureDetector::New();
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_PanGestureDetector_DownCast(void * jarg1) {
40673   void * jresult ;
40674   Dali::BaseHandle arg1 ;
40675   Dali::BaseHandle *argp1 ;
40676   Dali::PanGestureDetector result;
40677
40678   argp1 = (Dali::BaseHandle *)jarg1;
40679   if (!argp1) {
40680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40681     return 0;
40682   }
40683   arg1 = *argp1;
40684   {
40685     try {
40686       result = Dali::PanGestureDetector::DownCast(arg1);
40687     } catch (std::out_of_range& e) {
40688       {
40689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40690       };
40691     } catch (std::exception& e) {
40692       {
40693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40694       };
40695     } catch (Dali::DaliException e) {
40696       {
40697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40698       };
40699     } catch (...) {
40700       {
40701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40702       };
40703     }
40704   }
40705
40706   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40707   return jresult;
40708 }
40709
40710
40711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40712   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40713
40714   arg1 = (Dali::PanGestureDetector *)jarg1;
40715   {
40716     try {
40717       delete arg1;
40718     } catch (std::out_of_range& e) {
40719       {
40720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40721       };
40722     } catch (std::exception& e) {
40723       {
40724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40725       };
40726     } catch (Dali::DaliException e) {
40727       {
40728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40729       };
40730     } catch (...) {
40731       {
40732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40733       };
40734     }
40735   }
40736
40737 }
40738
40739
40740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40741   void * jresult ;
40742   Dali::PanGestureDetector *arg1 = 0 ;
40743   Dali::PanGestureDetector *result = 0 ;
40744
40745   arg1 = (Dali::PanGestureDetector *)jarg1;
40746   if (!arg1) {
40747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40748     return 0;
40749   }
40750   {
40751     try {
40752       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
40778   void * jresult ;
40779   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40780   Dali::PanGestureDetector *arg2 = 0 ;
40781   Dali::PanGestureDetector *result = 0 ;
40782
40783   arg1 = (Dali::PanGestureDetector *)jarg1;
40784   arg2 = (Dali::PanGestureDetector *)jarg2;
40785   if (!arg2) {
40786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40787     return 0;
40788   }
40789   {
40790     try {
40791       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40792     } catch (std::out_of_range& e) {
40793       {
40794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40795       };
40796     } catch (std::exception& e) {
40797       {
40798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40799       };
40800     } catch (Dali::DaliException e) {
40801       {
40802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40803       };
40804     } catch (...) {
40805       {
40806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40807       };
40808     }
40809   }
40810
40811   jresult = (void *)result;
40812   return jresult;
40813 }
40814
40815
40816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40817   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40818   unsigned int arg2 ;
40819
40820   arg1 = (Dali::PanGestureDetector *)jarg1;
40821   arg2 = (unsigned int)jarg2;
40822   {
40823     try {
40824       (arg1)->SetMinimumTouchesRequired(arg2);
40825     } catch (std::out_of_range& e) {
40826       {
40827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40828       };
40829     } catch (std::exception& e) {
40830       {
40831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40832       };
40833     } catch (Dali::DaliException e) {
40834       {
40835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40836       };
40837     } catch (...) {
40838       {
40839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40840       };
40841     }
40842   }
40843
40844 }
40845
40846
40847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40848   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40849   unsigned int arg2 ;
40850
40851   arg1 = (Dali::PanGestureDetector *)jarg1;
40852   arg2 = (unsigned int)jarg2;
40853   {
40854     try {
40855       (arg1)->SetMaximumTouchesRequired(arg2);
40856     } catch (std::out_of_range& e) {
40857       {
40858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40859       };
40860     } catch (std::exception& e) {
40861       {
40862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40863       };
40864     } catch (Dali::DaliException e) {
40865       {
40866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40867       };
40868     } catch (...) {
40869       {
40870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40871       };
40872     }
40873   }
40874
40875 }
40876
40877
40878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40879   unsigned int jresult ;
40880   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40881   unsigned int result;
40882
40883   arg1 = (Dali::PanGestureDetector *)jarg1;
40884   {
40885     try {
40886       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40887     } catch (std::out_of_range& e) {
40888       {
40889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40890       };
40891     } catch (std::exception& e) {
40892       {
40893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40894       };
40895     } catch (Dali::DaliException e) {
40896       {
40897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40898       };
40899     } catch (...) {
40900       {
40901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40902       };
40903     }
40904   }
40905
40906   jresult = result;
40907   return jresult;
40908 }
40909
40910
40911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40912   unsigned int jresult ;
40913   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40914   unsigned int result;
40915
40916   arg1 = (Dali::PanGestureDetector *)jarg1;
40917   {
40918     try {
40919       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40920     } catch (std::out_of_range& e) {
40921       {
40922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40923       };
40924     } catch (std::exception& e) {
40925       {
40926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40927       };
40928     } catch (Dali::DaliException e) {
40929       {
40930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40931       };
40932     } catch (...) {
40933       {
40934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40935       };
40936     }
40937   }
40938
40939   jresult = result;
40940   return jresult;
40941 }
40942
40943
40944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40945   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40946   Dali::Radian arg2 ;
40947   Dali::Radian arg3 ;
40948   Dali::Radian *argp2 ;
40949   Dali::Radian *argp3 ;
40950
40951   arg1 = (Dali::PanGestureDetector *)jarg1;
40952   argp2 = (Dali::Radian *)jarg2;
40953   if (!argp2) {
40954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40955     return ;
40956   }
40957   arg2 = *argp2;
40958   argp3 = (Dali::Radian *)jarg3;
40959   if (!argp3) {
40960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40961     return ;
40962   }
40963   arg3 = *argp3;
40964   {
40965     try {
40966       (arg1)->AddAngle(arg2,arg3);
40967     } catch (std::out_of_range& e) {
40968       {
40969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40970       };
40971     } catch (std::exception& e) {
40972       {
40973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40974       };
40975     } catch (Dali::DaliException e) {
40976       {
40977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40978       };
40979     } catch (...) {
40980       {
40981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40982       };
40983     }
40984   }
40985
40986 }
40987
40988
40989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40990   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40991   Dali::Radian arg2 ;
40992   Dali::Radian *argp2 ;
40993
40994   arg1 = (Dali::PanGestureDetector *)jarg1;
40995   argp2 = (Dali::Radian *)jarg2;
40996   if (!argp2) {
40997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40998     return ;
40999   }
41000   arg2 = *argp2;
41001   {
41002     try {
41003       (arg1)->AddAngle(arg2);
41004     } catch (std::out_of_range& e) {
41005       {
41006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41007       };
41008     } catch (std::exception& e) {
41009       {
41010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41011       };
41012     } catch (Dali::DaliException e) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41015       };
41016     } catch (...) {
41017       {
41018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41019       };
41020     }
41021   }
41022
41023 }
41024
41025
41026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41027   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41028   Dali::Radian arg2 ;
41029   Dali::Radian arg3 ;
41030   Dali::Radian *argp2 ;
41031   Dali::Radian *argp3 ;
41032
41033   arg1 = (Dali::PanGestureDetector *)jarg1;
41034   argp2 = (Dali::Radian *)jarg2;
41035   if (!argp2) {
41036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41037     return ;
41038   }
41039   arg2 = *argp2;
41040   argp3 = (Dali::Radian *)jarg3;
41041   if (!argp3) {
41042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41043     return ;
41044   }
41045   arg3 = *argp3;
41046   {
41047     try {
41048       (arg1)->AddDirection(arg2,arg3);
41049     } catch (std::out_of_range& e) {
41050       {
41051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41052       };
41053     } catch (std::exception& e) {
41054       {
41055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41056       };
41057     } catch (Dali::DaliException e) {
41058       {
41059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41060       };
41061     } catch (...) {
41062       {
41063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41064       };
41065     }
41066   }
41067
41068 }
41069
41070
41071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41072   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41073   Dali::Radian arg2 ;
41074   Dali::Radian *argp2 ;
41075
41076   arg1 = (Dali::PanGestureDetector *)jarg1;
41077   argp2 = (Dali::Radian *)jarg2;
41078   if (!argp2) {
41079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41080     return ;
41081   }
41082   arg2 = *argp2;
41083   {
41084     try {
41085       (arg1)->AddDirection(arg2);
41086     } catch (std::out_of_range& e) {
41087       {
41088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41089       };
41090     } catch (std::exception& e) {
41091       {
41092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41093       };
41094     } catch (Dali::DaliException e) {
41095       {
41096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41097       };
41098     } catch (...) {
41099       {
41100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41101       };
41102     }
41103   }
41104
41105 }
41106
41107
41108 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41109   unsigned long jresult ;
41110   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41111   size_t result;
41112
41113   arg1 = (Dali::PanGestureDetector *)jarg1;
41114   {
41115     try {
41116       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41117     } catch (std::out_of_range& e) {
41118       {
41119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41120       };
41121     } catch (std::exception& e) {
41122       {
41123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41124       };
41125     } catch (Dali::DaliException e) {
41126       {
41127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41128       };
41129     } catch (...) {
41130       {
41131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41132       };
41133     }
41134   }
41135
41136   jresult = (unsigned long)result;
41137   return jresult;
41138 }
41139
41140
41141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41142   void * jresult ;
41143   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41144   size_t arg2 ;
41145   Dali::PanGestureDetector::AngleThresholdPair result;
41146
41147   arg1 = (Dali::PanGestureDetector *)jarg1;
41148   arg2 = (size_t)jarg2;
41149   {
41150     try {
41151       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41152     } catch (std::out_of_range& e) {
41153       {
41154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41155       };
41156     } catch (std::exception& e) {
41157       {
41158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41159       };
41160     } catch (Dali::DaliException e) {
41161       {
41162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41163       };
41164     } catch (...) {
41165       {
41166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41167       };
41168     }
41169   }
41170
41171   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41172   return jresult;
41173 }
41174
41175
41176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41177   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41178
41179   arg1 = (Dali::PanGestureDetector *)jarg1;
41180   {
41181     try {
41182       (arg1)->ClearAngles();
41183     } catch (std::out_of_range& e) {
41184       {
41185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41186       };
41187     } catch (std::exception& e) {
41188       {
41189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41190       };
41191     } catch (Dali::DaliException e) {
41192       {
41193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41194       };
41195     } catch (...) {
41196       {
41197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41198       };
41199     }
41200   }
41201
41202 }
41203
41204
41205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41206   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41207   Dali::Radian arg2 ;
41208   Dali::Radian *argp2 ;
41209
41210   arg1 = (Dali::PanGestureDetector *)jarg1;
41211   argp2 = (Dali::Radian *)jarg2;
41212   if (!argp2) {
41213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41214     return ;
41215   }
41216   arg2 = *argp2;
41217   {
41218     try {
41219       (arg1)->RemoveAngle(arg2);
41220     } catch (std::out_of_range& e) {
41221       {
41222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41223       };
41224     } catch (std::exception& e) {
41225       {
41226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41227       };
41228     } catch (Dali::DaliException e) {
41229       {
41230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41231       };
41232     } catch (...) {
41233       {
41234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41235       };
41236     }
41237   }
41238
41239 }
41240
41241
41242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41243   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41244   Dali::Radian arg2 ;
41245   Dali::Radian *argp2 ;
41246
41247   arg1 = (Dali::PanGestureDetector *)jarg1;
41248   argp2 = (Dali::Radian *)jarg2;
41249   if (!argp2) {
41250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41251     return ;
41252   }
41253   arg2 = *argp2;
41254   {
41255     try {
41256       (arg1)->RemoveDirection(arg2);
41257     } catch (std::out_of_range& e) {
41258       {
41259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41260       };
41261     } catch (std::exception& e) {
41262       {
41263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41264       };
41265     } catch (Dali::DaliException e) {
41266       {
41267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41268       };
41269     } catch (...) {
41270       {
41271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41272       };
41273     }
41274   }
41275
41276 }
41277
41278
41279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41280   void * jresult ;
41281   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41282   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41283
41284   arg1 = (Dali::PanGestureDetector *)jarg1;
41285   {
41286     try {
41287       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41288     } catch (std::out_of_range& e) {
41289       {
41290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41291       };
41292     } catch (std::exception& e) {
41293       {
41294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41295       };
41296     } catch (Dali::DaliException e) {
41297       {
41298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41299       };
41300     } catch (...) {
41301       {
41302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41303       };
41304     }
41305   }
41306
41307   jresult = (void *)result;
41308   return jresult;
41309 }
41310
41311
41312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41313   Dali::PanGesture *arg1 = 0 ;
41314
41315   arg1 = (Dali::PanGesture *)jarg1;
41316   if (!arg1) {
41317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41318     return ;
41319   }
41320   {
41321     try {
41322       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41323     } catch (std::out_of_range& e) {
41324       {
41325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41326       };
41327     } catch (std::exception& e) {
41328       {
41329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41330       };
41331     } catch (Dali::DaliException e) {
41332       {
41333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41334       };
41335     } catch (...) {
41336       {
41337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41338       };
41339     }
41340   }
41341
41342 }
41343
41344
41345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41346   void * jresult ;
41347   Dali::PanGesture *result = 0 ;
41348
41349   {
41350     try {
41351       result = (Dali::PanGesture *)new Dali::PanGesture();
41352     } catch (std::out_of_range& e) {
41353       {
41354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41355       };
41356     } catch (std::exception& e) {
41357       {
41358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41359       };
41360     } catch (Dali::DaliException e) {
41361       {
41362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41363       };
41364     } catch (...) {
41365       {
41366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41367       };
41368     }
41369   }
41370
41371   jresult = (void *)result;
41372   return jresult;
41373 }
41374
41375
41376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41377   void * jresult ;
41378   Dali::Gesture::State arg1 ;
41379   Dali::PanGesture *result = 0 ;
41380
41381   arg1 = (Dali::Gesture::State)jarg1;
41382   {
41383     try {
41384       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41385     } catch (std::out_of_range& e) {
41386       {
41387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41388       };
41389     } catch (std::exception& e) {
41390       {
41391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41392       };
41393     } catch (Dali::DaliException e) {
41394       {
41395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41396       };
41397     } catch (...) {
41398       {
41399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41400       };
41401     }
41402   }
41403
41404   jresult = (void *)result;
41405   return jresult;
41406 }
41407
41408
41409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41410   void * jresult ;
41411   Dali::PanGesture *arg1 = 0 ;
41412   Dali::PanGesture *result = 0 ;
41413
41414   arg1 = (Dali::PanGesture *)jarg1;
41415   if (!arg1) {
41416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41417     return 0;
41418   }
41419   {
41420     try {
41421       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
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_PanGesture_Assign(void * jarg1, void * jarg2) {
41447   void * jresult ;
41448   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41449   Dali::PanGesture *arg2 = 0 ;
41450   Dali::PanGesture *result = 0 ;
41451
41452   arg1 = (Dali::PanGesture *)jarg1;
41453   arg2 = (Dali::PanGesture *)jarg2;
41454   if (!arg2) {
41455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41456     return 0;
41457   }
41458   {
41459     try {
41460       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41461     } catch (std::out_of_range& e) {
41462       {
41463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41464       };
41465     } catch (std::exception& e) {
41466       {
41467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41468       };
41469     } catch (Dali::DaliException e) {
41470       {
41471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41472       };
41473     } catch (...) {
41474       {
41475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41476       };
41477     }
41478   }
41479
41480   jresult = (void *)result;
41481   return jresult;
41482 }
41483
41484
41485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41486   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41487
41488   arg1 = (Dali::PanGesture *)jarg1;
41489   {
41490     try {
41491       delete arg1;
41492     } catch (std::out_of_range& e) {
41493       {
41494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41495       };
41496     } catch (std::exception& e) {
41497       {
41498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41499       };
41500     } catch (Dali::DaliException e) {
41501       {
41502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41503       };
41504     } catch (...) {
41505       {
41506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41507       };
41508     }
41509   }
41510
41511 }
41512
41513
41514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41515   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41516   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41517
41518   arg1 = (Dali::PanGesture *)jarg1;
41519   arg2 = (Dali::Vector2 *)jarg2;
41520   if (arg1) (arg1)->velocity = *arg2;
41521 }
41522
41523
41524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41525   void * jresult ;
41526   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41527   Dali::Vector2 *result = 0 ;
41528
41529   arg1 = (Dali::PanGesture *)jarg1;
41530   result = (Dali::Vector2 *)& ((arg1)->velocity);
41531   jresult = (void *)result;
41532   return jresult;
41533 }
41534
41535
41536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41537   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41538   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41539
41540   arg1 = (Dali::PanGesture *)jarg1;
41541   arg2 = (Dali::Vector2 *)jarg2;
41542   if (arg1) (arg1)->displacement = *arg2;
41543 }
41544
41545
41546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41547   void * jresult ;
41548   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41549   Dali::Vector2 *result = 0 ;
41550
41551   arg1 = (Dali::PanGesture *)jarg1;
41552   result = (Dali::Vector2 *)& ((arg1)->displacement);
41553   jresult = (void *)result;
41554   return jresult;
41555 }
41556
41557
41558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41559   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41560   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41561
41562   arg1 = (Dali::PanGesture *)jarg1;
41563   arg2 = (Dali::Vector2 *)jarg2;
41564   if (arg1) (arg1)->position = *arg2;
41565 }
41566
41567
41568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41569   void * jresult ;
41570   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41571   Dali::Vector2 *result = 0 ;
41572
41573   arg1 = (Dali::PanGesture *)jarg1;
41574   result = (Dali::Vector2 *)& ((arg1)->position);
41575   jresult = (void *)result;
41576   return jresult;
41577 }
41578
41579
41580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41581   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41582   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41583
41584   arg1 = (Dali::PanGesture *)jarg1;
41585   arg2 = (Dali::Vector2 *)jarg2;
41586   if (arg1) (arg1)->screenVelocity = *arg2;
41587 }
41588
41589
41590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41591   void * jresult ;
41592   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41593   Dali::Vector2 *result = 0 ;
41594
41595   arg1 = (Dali::PanGesture *)jarg1;
41596   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41597   jresult = (void *)result;
41598   return jresult;
41599 }
41600
41601
41602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41603   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41604   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41605
41606   arg1 = (Dali::PanGesture *)jarg1;
41607   arg2 = (Dali::Vector2 *)jarg2;
41608   if (arg1) (arg1)->screenDisplacement = *arg2;
41609 }
41610
41611
41612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41613   void * jresult ;
41614   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41615   Dali::Vector2 *result = 0 ;
41616
41617   arg1 = (Dali::PanGesture *)jarg1;
41618   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41619   jresult = (void *)result;
41620   return jresult;
41621 }
41622
41623
41624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41625   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41626   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41627
41628   arg1 = (Dali::PanGesture *)jarg1;
41629   arg2 = (Dali::Vector2 *)jarg2;
41630   if (arg1) (arg1)->screenPosition = *arg2;
41631 }
41632
41633
41634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41635   void * jresult ;
41636   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41637   Dali::Vector2 *result = 0 ;
41638
41639   arg1 = (Dali::PanGesture *)jarg1;
41640   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41641   jresult = (void *)result;
41642   return jresult;
41643 }
41644
41645
41646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41647   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41648   unsigned int arg2 ;
41649
41650   arg1 = (Dali::PanGesture *)jarg1;
41651   arg2 = (unsigned int)jarg2;
41652   if (arg1) (arg1)->numberOfTouches = arg2;
41653 }
41654
41655
41656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41657   unsigned int jresult ;
41658   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41659   unsigned int result;
41660
41661   arg1 = (Dali::PanGesture *)jarg1;
41662   result = (unsigned int) ((arg1)->numberOfTouches);
41663   jresult = result;
41664   return jresult;
41665 }
41666
41667
41668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41669   float jresult ;
41670   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41671   float result;
41672
41673   arg1 = (Dali::PanGesture *)jarg1;
41674   {
41675     try {
41676       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41677     } catch (std::out_of_range& e) {
41678       {
41679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41680       };
41681     } catch (std::exception& e) {
41682       {
41683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41684       };
41685     } catch (Dali::DaliException e) {
41686       {
41687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41688       };
41689     } catch (...) {
41690       {
41691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41692       };
41693     }
41694   }
41695
41696   jresult = result;
41697   return jresult;
41698 }
41699
41700
41701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41702   float jresult ;
41703   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41704   float result;
41705
41706   arg1 = (Dali::PanGesture *)jarg1;
41707   {
41708     try {
41709       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41710     } catch (std::out_of_range& e) {
41711       {
41712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41713       };
41714     } catch (std::exception& e) {
41715       {
41716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41717       };
41718     } catch (Dali::DaliException e) {
41719       {
41720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41721       };
41722     } catch (...) {
41723       {
41724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41725       };
41726     }
41727   }
41728
41729   jresult = result;
41730   return jresult;
41731 }
41732
41733
41734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41735   float jresult ;
41736   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41737   float result;
41738
41739   arg1 = (Dali::PanGesture *)jarg1;
41740   {
41741     try {
41742       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41743     } catch (std::out_of_range& e) {
41744       {
41745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41746       };
41747     } catch (std::exception& e) {
41748       {
41749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41750       };
41751     } catch (Dali::DaliException e) {
41752       {
41753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41754       };
41755     } catch (...) {
41756       {
41757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41758       };
41759     }
41760   }
41761
41762   jresult = result;
41763   return jresult;
41764 }
41765
41766
41767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41768   float jresult ;
41769   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41770   float result;
41771
41772   arg1 = (Dali::PanGesture *)jarg1;
41773   {
41774     try {
41775       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41776     } catch (std::out_of_range& e) {
41777       {
41778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41779       };
41780     } catch (std::exception& e) {
41781       {
41782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41783       };
41784     } catch (Dali::DaliException e) {
41785       {
41786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41787       };
41788     } catch (...) {
41789       {
41790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41791       };
41792     }
41793   }
41794
41795   jresult = result;
41796   return jresult;
41797 }
41798
41799
41800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41801   void * jresult ;
41802   Dali::PinchGestureDetector *result = 0 ;
41803
41804   {
41805     try {
41806       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41807     } catch (std::out_of_range& e) {
41808       {
41809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41810       };
41811     } catch (std::exception& e) {
41812       {
41813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41814       };
41815     } catch (Dali::DaliException e) {
41816       {
41817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41818       };
41819     } catch (...) {
41820       {
41821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41822       };
41823     }
41824   }
41825
41826   jresult = (void *)result;
41827   return jresult;
41828 }
41829
41830
41831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41832   void * jresult ;
41833   Dali::PinchGestureDetector result;
41834
41835   {
41836     try {
41837       result = Dali::PinchGestureDetector::New();
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_PinchGestureDetector_DownCast(void * jarg1) {
41863   void * jresult ;
41864   Dali::BaseHandle arg1 ;
41865   Dali::BaseHandle *argp1 ;
41866   Dali::PinchGestureDetector result;
41867
41868   argp1 = (Dali::BaseHandle *)jarg1;
41869   if (!argp1) {
41870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41871     return 0;
41872   }
41873   arg1 = *argp1;
41874   {
41875     try {
41876       result = Dali::PinchGestureDetector::DownCast(arg1);
41877     } catch (std::out_of_range& e) {
41878       {
41879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41880       };
41881     } catch (std::exception& e) {
41882       {
41883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41884       };
41885     } catch (Dali::DaliException e) {
41886       {
41887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41888       };
41889     } catch (...) {
41890       {
41891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41892       };
41893     }
41894   }
41895
41896   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41897   return jresult;
41898 }
41899
41900
41901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41902   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41903
41904   arg1 = (Dali::PinchGestureDetector *)jarg1;
41905   {
41906     try {
41907       delete arg1;
41908     } catch (std::out_of_range& e) {
41909       {
41910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41911       };
41912     } catch (std::exception& e) {
41913       {
41914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41915       };
41916     } catch (Dali::DaliException e) {
41917       {
41918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41919       };
41920     } catch (...) {
41921       {
41922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41923       };
41924     }
41925   }
41926
41927 }
41928
41929
41930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41931   void * jresult ;
41932   Dali::PinchGestureDetector *arg1 = 0 ;
41933   Dali::PinchGestureDetector *result = 0 ;
41934
41935   arg1 = (Dali::PinchGestureDetector *)jarg1;
41936   if (!arg1) {
41937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41938     return 0;
41939   }
41940   {
41941     try {
41942       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
41968   void * jresult ;
41969   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41970   Dali::PinchGestureDetector *arg2 = 0 ;
41971   Dali::PinchGestureDetector *result = 0 ;
41972
41973   arg1 = (Dali::PinchGestureDetector *)jarg1;
41974   arg2 = (Dali::PinchGestureDetector *)jarg2;
41975   if (!arg2) {
41976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41977     return 0;
41978   }
41979   {
41980     try {
41981       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41982     } catch (std::out_of_range& e) {
41983       {
41984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41985       };
41986     } catch (std::exception& e) {
41987       {
41988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41989       };
41990     } catch (Dali::DaliException e) {
41991       {
41992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41993       };
41994     } catch (...) {
41995       {
41996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41997       };
41998     }
41999   }
42000
42001   jresult = (void *)result;
42002   return jresult;
42003 }
42004
42005
42006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42007   void * jresult ;
42008   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42009   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42010
42011   arg1 = (Dali::PinchGestureDetector *)jarg1;
42012   {
42013     try {
42014       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42015     } catch (std::out_of_range& e) {
42016       {
42017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42018       };
42019     } catch (std::exception& e) {
42020       {
42021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42022       };
42023     } catch (Dali::DaliException e) {
42024       {
42025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42026       };
42027     } catch (...) {
42028       {
42029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42030       };
42031     }
42032   }
42033
42034   jresult = (void *)result;
42035   return jresult;
42036 }
42037
42038
42039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42040   void * jresult ;
42041   Dali::Gesture::State arg1 ;
42042   Dali::PinchGesture *result = 0 ;
42043
42044   arg1 = (Dali::Gesture::State)jarg1;
42045   {
42046     try {
42047       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42048     } catch (std::out_of_range& e) {
42049       {
42050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42051       };
42052     } catch (std::exception& e) {
42053       {
42054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42055       };
42056     } catch (Dali::DaliException e) {
42057       {
42058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42059       };
42060     } catch (...) {
42061       {
42062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42063       };
42064     }
42065   }
42066
42067   jresult = (void *)result;
42068   return jresult;
42069 }
42070
42071
42072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42073   void * jresult ;
42074   Dali::PinchGesture *arg1 = 0 ;
42075   Dali::PinchGesture *result = 0 ;
42076
42077   arg1 = (Dali::PinchGesture *)jarg1;
42078   if (!arg1) {
42079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42080     return 0;
42081   }
42082   {
42083     try {
42084       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
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_PinchGesture_Assign(void * jarg1, void * jarg2) {
42110   void * jresult ;
42111   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42112   Dali::PinchGesture *arg2 = 0 ;
42113   Dali::PinchGesture *result = 0 ;
42114
42115   arg1 = (Dali::PinchGesture *)jarg1;
42116   arg2 = (Dali::PinchGesture *)jarg2;
42117   if (!arg2) {
42118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42119     return 0;
42120   }
42121   {
42122     try {
42123       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42124     } catch (std::out_of_range& e) {
42125       {
42126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42127       };
42128     } catch (std::exception& e) {
42129       {
42130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42131       };
42132     } catch (Dali::DaliException e) {
42133       {
42134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42135       };
42136     } catch (...) {
42137       {
42138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42139       };
42140     }
42141   }
42142
42143   jresult = (void *)result;
42144   return jresult;
42145 }
42146
42147
42148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42149   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42150
42151   arg1 = (Dali::PinchGesture *)jarg1;
42152   {
42153     try {
42154       delete arg1;
42155     } catch (std::out_of_range& e) {
42156       {
42157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42158       };
42159     } catch (std::exception& e) {
42160       {
42161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42162       };
42163     } catch (Dali::DaliException e) {
42164       {
42165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42166       };
42167     } catch (...) {
42168       {
42169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42170       };
42171     }
42172   }
42173
42174 }
42175
42176
42177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42178   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42179   float arg2 ;
42180
42181   arg1 = (Dali::PinchGesture *)jarg1;
42182   arg2 = (float)jarg2;
42183   if (arg1) (arg1)->scale = arg2;
42184 }
42185
42186
42187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42188   float jresult ;
42189   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42190   float result;
42191
42192   arg1 = (Dali::PinchGesture *)jarg1;
42193   result = (float) ((arg1)->scale);
42194   jresult = result;
42195   return jresult;
42196 }
42197
42198
42199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42200   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42201   float arg2 ;
42202
42203   arg1 = (Dali::PinchGesture *)jarg1;
42204   arg2 = (float)jarg2;
42205   if (arg1) (arg1)->speed = arg2;
42206 }
42207
42208
42209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42210   float jresult ;
42211   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42212   float result;
42213
42214   arg1 = (Dali::PinchGesture *)jarg1;
42215   result = (float) ((arg1)->speed);
42216   jresult = result;
42217   return jresult;
42218 }
42219
42220
42221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42222   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42223   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42224
42225   arg1 = (Dali::PinchGesture *)jarg1;
42226   arg2 = (Dali::Vector2 *)jarg2;
42227   if (arg1) (arg1)->screenCenterPoint = *arg2;
42228 }
42229
42230
42231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42232   void * jresult ;
42233   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42234   Dali::Vector2 *result = 0 ;
42235
42236   arg1 = (Dali::PinchGesture *)jarg1;
42237   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42238   jresult = (void *)result;
42239   return jresult;
42240 }
42241
42242
42243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42244   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42245   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42246
42247   arg1 = (Dali::PinchGesture *)jarg1;
42248   arg2 = (Dali::Vector2 *)jarg2;
42249   if (arg1) (arg1)->localCenterPoint = *arg2;
42250 }
42251
42252
42253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42254   void * jresult ;
42255   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42256   Dali::Vector2 *result = 0 ;
42257
42258   arg1 = (Dali::PinchGesture *)jarg1;
42259   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42260   jresult = (void *)result;
42261   return jresult;
42262 }
42263
42264
42265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42266   void * jresult ;
42267   Dali::TapGestureDetector *result = 0 ;
42268
42269   {
42270     try {
42271       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42272     } catch (std::out_of_range& e) {
42273       {
42274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42275       };
42276     } catch (std::exception& e) {
42277       {
42278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42279       };
42280     } catch (Dali::DaliException e) {
42281       {
42282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42283       };
42284     } catch (...) {
42285       {
42286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42287       };
42288     }
42289   }
42290
42291   jresult = (void *)result;
42292   return jresult;
42293 }
42294
42295
42296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42297   void * jresult ;
42298   Dali::TapGestureDetector result;
42299
42300   {
42301     try {
42302       result = Dali::TapGestureDetector::New();
42303     } catch (std::out_of_range& e) {
42304       {
42305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42306       };
42307     } catch (std::exception& e) {
42308       {
42309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42310       };
42311     } catch (Dali::DaliException e) {
42312       {
42313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42314       };
42315     } catch (...) {
42316       {
42317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42318       };
42319     }
42320   }
42321
42322   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42323   return jresult;
42324 }
42325
42326
42327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42328   void * jresult ;
42329   unsigned int arg1 ;
42330   Dali::TapGestureDetector result;
42331
42332   arg1 = (unsigned int)jarg1;
42333   {
42334     try {
42335       result = Dali::TapGestureDetector::New(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_TapGestureDetector_DownCast(void * jarg1) {
42361   void * jresult ;
42362   Dali::BaseHandle arg1 ;
42363   Dali::BaseHandle *argp1 ;
42364   Dali::TapGestureDetector result;
42365
42366   argp1 = (Dali::BaseHandle *)jarg1;
42367   if (!argp1) {
42368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42369     return 0;
42370   }
42371   arg1 = *argp1;
42372   {
42373     try {
42374       result = Dali::TapGestureDetector::DownCast(arg1);
42375     } catch (std::out_of_range& e) {
42376       {
42377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42378       };
42379     } catch (std::exception& e) {
42380       {
42381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42382       };
42383     } catch (Dali::DaliException e) {
42384       {
42385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42386       };
42387     } catch (...) {
42388       {
42389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42390       };
42391     }
42392   }
42393
42394   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42395   return jresult;
42396 }
42397
42398
42399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42400   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42401
42402   arg1 = (Dali::TapGestureDetector *)jarg1;
42403   {
42404     try {
42405       delete arg1;
42406     } catch (std::out_of_range& e) {
42407       {
42408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42409       };
42410     } catch (std::exception& e) {
42411       {
42412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42413       };
42414     } catch (Dali::DaliException e) {
42415       {
42416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42417       };
42418     } catch (...) {
42419       {
42420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42421       };
42422     }
42423   }
42424
42425 }
42426
42427
42428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42429   void * jresult ;
42430   Dali::TapGestureDetector *arg1 = 0 ;
42431   Dali::TapGestureDetector *result = 0 ;
42432
42433   arg1 = (Dali::TapGestureDetector *)jarg1;
42434   if (!arg1) {
42435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42436     return 0;
42437   }
42438   {
42439     try {
42440       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
42466   void * jresult ;
42467   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42468   Dali::TapGestureDetector *arg2 = 0 ;
42469   Dali::TapGestureDetector *result = 0 ;
42470
42471   arg1 = (Dali::TapGestureDetector *)jarg1;
42472   arg2 = (Dali::TapGestureDetector *)jarg2;
42473   if (!arg2) {
42474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42475     return 0;
42476   }
42477   {
42478     try {
42479       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42480     } catch (std::out_of_range& e) {
42481       {
42482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42483       };
42484     } catch (std::exception& e) {
42485       {
42486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42487       };
42488     } catch (Dali::DaliException e) {
42489       {
42490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42491       };
42492     } catch (...) {
42493       {
42494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42495       };
42496     }
42497   }
42498
42499   jresult = (void *)result;
42500   return jresult;
42501 }
42502
42503
42504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42505   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42506   unsigned int arg2 ;
42507
42508   arg1 = (Dali::TapGestureDetector *)jarg1;
42509   arg2 = (unsigned int)jarg2;
42510   {
42511     try {
42512       (arg1)->SetMinimumTapsRequired(arg2);
42513     } catch (std::out_of_range& e) {
42514       {
42515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42516       };
42517     } catch (std::exception& e) {
42518       {
42519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42520       };
42521     } catch (Dali::DaliException e) {
42522       {
42523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42524       };
42525     } catch (...) {
42526       {
42527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42528       };
42529     }
42530   }
42531
42532 }
42533
42534
42535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42536   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42537   unsigned int arg2 ;
42538
42539   arg1 = (Dali::TapGestureDetector *)jarg1;
42540   arg2 = (unsigned int)jarg2;
42541   {
42542     try {
42543       (arg1)->SetMaximumTapsRequired(arg2);
42544     } catch (std::out_of_range& e) {
42545       {
42546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42547       };
42548     } catch (std::exception& e) {
42549       {
42550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42551       };
42552     } catch (Dali::DaliException e) {
42553       {
42554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42555       };
42556     } catch (...) {
42557       {
42558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42559       };
42560     }
42561   }
42562
42563 }
42564
42565
42566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42567   unsigned int jresult ;
42568   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42569   unsigned int result;
42570
42571   arg1 = (Dali::TapGestureDetector *)jarg1;
42572   {
42573     try {
42574       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42575     } catch (std::out_of_range& e) {
42576       {
42577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42578       };
42579     } catch (std::exception& e) {
42580       {
42581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42582       };
42583     } catch (Dali::DaliException e) {
42584       {
42585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42586       };
42587     } catch (...) {
42588       {
42589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42590       };
42591     }
42592   }
42593
42594   jresult = result;
42595   return jresult;
42596 }
42597
42598
42599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42600   unsigned int jresult ;
42601   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42602   unsigned int result;
42603
42604   arg1 = (Dali::TapGestureDetector *)jarg1;
42605   {
42606     try {
42607       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42608     } catch (std::out_of_range& e) {
42609       {
42610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42611       };
42612     } catch (std::exception& e) {
42613       {
42614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42615       };
42616     } catch (Dali::DaliException e) {
42617       {
42618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42619       };
42620     } catch (...) {
42621       {
42622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42623       };
42624     }
42625   }
42626
42627   jresult = result;
42628   return jresult;
42629 }
42630
42631
42632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42633   void * jresult ;
42634   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42635   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42636
42637   arg1 = (Dali::TapGestureDetector *)jarg1;
42638   {
42639     try {
42640       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42641     } catch (std::out_of_range& e) {
42642       {
42643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42644       };
42645     } catch (std::exception& e) {
42646       {
42647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42648       };
42649     } catch (Dali::DaliException e) {
42650       {
42651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42652       };
42653     } catch (...) {
42654       {
42655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42656       };
42657     }
42658   }
42659
42660   jresult = (void *)result;
42661   return jresult;
42662 }
42663
42664
42665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42666   void * jresult ;
42667   Dali::TapGesture *result = 0 ;
42668
42669   {
42670     try {
42671       result = (Dali::TapGesture *)new Dali::TapGesture();
42672     } catch (std::out_of_range& e) {
42673       {
42674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42675       };
42676     } catch (std::exception& e) {
42677       {
42678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42679       };
42680     } catch (Dali::DaliException e) {
42681       {
42682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42683       };
42684     } catch (...) {
42685       {
42686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42687       };
42688     }
42689   }
42690
42691   jresult = (void *)result;
42692   return jresult;
42693 }
42694
42695
42696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42697   void * jresult ;
42698   Dali::TapGesture *arg1 = 0 ;
42699   Dali::TapGesture *result = 0 ;
42700
42701   arg1 = (Dali::TapGesture *)jarg1;
42702   if (!arg1) {
42703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42704     return 0;
42705   }
42706   {
42707     try {
42708       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
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_TapGesture_Assign(void * jarg1, void * jarg2) {
42734   void * jresult ;
42735   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42736   Dali::TapGesture *arg2 = 0 ;
42737   Dali::TapGesture *result = 0 ;
42738
42739   arg1 = (Dali::TapGesture *)jarg1;
42740   arg2 = (Dali::TapGesture *)jarg2;
42741   if (!arg2) {
42742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42743     return 0;
42744   }
42745   {
42746     try {
42747       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42748     } catch (std::out_of_range& e) {
42749       {
42750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42751       };
42752     } catch (std::exception& e) {
42753       {
42754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42755       };
42756     } catch (Dali::DaliException e) {
42757       {
42758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42759       };
42760     } catch (...) {
42761       {
42762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42763       };
42764     }
42765   }
42766
42767   jresult = (void *)result;
42768   return jresult;
42769 }
42770
42771
42772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42773   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42774
42775   arg1 = (Dali::TapGesture *)jarg1;
42776   {
42777     try {
42778       delete arg1;
42779     } catch (std::out_of_range& e) {
42780       {
42781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42782       };
42783     } catch (std::exception& e) {
42784       {
42785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42786       };
42787     } catch (Dali::DaliException e) {
42788       {
42789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42790       };
42791     } catch (...) {
42792       {
42793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42794       };
42795     }
42796   }
42797
42798 }
42799
42800
42801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42802   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42803   unsigned int arg2 ;
42804
42805   arg1 = (Dali::TapGesture *)jarg1;
42806   arg2 = (unsigned int)jarg2;
42807   if (arg1) (arg1)->numberOfTaps = arg2;
42808 }
42809
42810
42811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42812   unsigned int jresult ;
42813   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42814   unsigned int result;
42815
42816   arg1 = (Dali::TapGesture *)jarg1;
42817   result = (unsigned int) ((arg1)->numberOfTaps);
42818   jresult = result;
42819   return jresult;
42820 }
42821
42822
42823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42824   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42825   unsigned int arg2 ;
42826
42827   arg1 = (Dali::TapGesture *)jarg1;
42828   arg2 = (unsigned int)jarg2;
42829   if (arg1) (arg1)->numberOfTouches = arg2;
42830 }
42831
42832
42833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42834   unsigned int jresult ;
42835   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42836   unsigned int result;
42837
42838   arg1 = (Dali::TapGesture *)jarg1;
42839   result = (unsigned int) ((arg1)->numberOfTouches);
42840   jresult = result;
42841   return jresult;
42842 }
42843
42844
42845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42846   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42847   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42848
42849   arg1 = (Dali::TapGesture *)jarg1;
42850   arg2 = (Dali::Vector2 *)jarg2;
42851   if (arg1) (arg1)->screenPoint = *arg2;
42852 }
42853
42854
42855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42856   void * jresult ;
42857   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42858   Dali::Vector2 *result = 0 ;
42859
42860   arg1 = (Dali::TapGesture *)jarg1;
42861   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42862   jresult = (void *)result;
42863   return jresult;
42864 }
42865
42866
42867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42868   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42869   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42870
42871   arg1 = (Dali::TapGesture *)jarg1;
42872   arg2 = (Dali::Vector2 *)jarg2;
42873   if (arg1) (arg1)->localPoint = *arg2;
42874 }
42875
42876
42877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42878   void * jresult ;
42879   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42880   Dali::Vector2 *result = 0 ;
42881
42882   arg1 = (Dali::TapGesture *)jarg1;
42883   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42884   jresult = (void *)result;
42885   return jresult;
42886 }
42887
42888
42889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42890   void * jresult ;
42891   Dali::AlphaFunction *result = 0 ;
42892
42893   {
42894     try {
42895       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42896     } catch (std::out_of_range& e) {
42897       {
42898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42899       };
42900     } catch (std::exception& e) {
42901       {
42902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42903       };
42904     } catch (Dali::DaliException e) {
42905       {
42906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42907       };
42908     } catch (...) {
42909       {
42910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42911       };
42912     }
42913   }
42914
42915   jresult = (void *)result;
42916   return jresult;
42917 }
42918
42919
42920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42921   void * jresult ;
42922   Dali::AlphaFunction::BuiltinFunction arg1 ;
42923   Dali::AlphaFunction *result = 0 ;
42924
42925   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42926   {
42927     try {
42928       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42929     } catch (std::out_of_range& e) {
42930       {
42931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42932       };
42933     } catch (std::exception& e) {
42934       {
42935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42936       };
42937     } catch (Dali::DaliException e) {
42938       {
42939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42940       };
42941     } catch (...) {
42942       {
42943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42944       };
42945     }
42946   }
42947
42948   jresult = (void *)result;
42949   return jresult;
42950 }
42951
42952
42953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42954   void * jresult ;
42955   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42956   Dali::AlphaFunction *result = 0 ;
42957
42958   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42959   {
42960     try {
42961       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42962     } catch (std::out_of_range& e) {
42963       {
42964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42965       };
42966     } catch (std::exception& e) {
42967       {
42968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42969       };
42970     } catch (Dali::DaliException e) {
42971       {
42972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42973       };
42974     } catch (...) {
42975       {
42976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42977       };
42978     }
42979   }
42980
42981   jresult = (void *)result;
42982   return jresult;
42983 }
42984
42985
42986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42987   void * jresult ;
42988   Dali::Vector2 *arg1 = 0 ;
42989   Dali::Vector2 *arg2 = 0 ;
42990   Dali::AlphaFunction *result = 0 ;
42991
42992   arg1 = (Dali::Vector2 *)jarg1;
42993   if (!arg1) {
42994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42995     return 0;
42996   }
42997   arg2 = (Dali::Vector2 *)jarg2;
42998   if (!arg2) {
42999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43000     return 0;
43001   }
43002   {
43003     try {
43004       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43005     } catch (std::out_of_range& e) {
43006       {
43007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43008       };
43009     } catch (std::exception& e) {
43010       {
43011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43012       };
43013     } catch (Dali::DaliException e) {
43014       {
43015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43016       };
43017     } catch (...) {
43018       {
43019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43020       };
43021     }
43022   }
43023
43024   jresult = (void *)result;
43025   return jresult;
43026 }
43027
43028
43029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43030   void * jresult ;
43031   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43032   Dali::Vector4 result;
43033
43034   arg1 = (Dali::AlphaFunction *)jarg1;
43035   {
43036     try {
43037       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43038     } catch (std::out_of_range& e) {
43039       {
43040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43041       };
43042     } catch (std::exception& e) {
43043       {
43044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43045       };
43046     } catch (Dali::DaliException e) {
43047       {
43048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43049       };
43050     } catch (...) {
43051       {
43052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43053       };
43054     }
43055   }
43056
43057   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43058   return jresult;
43059 }
43060
43061
43062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43063   void * jresult ;
43064   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43065   Dali::AlphaFunctionPrototype result;
43066
43067   arg1 = (Dali::AlphaFunction *)jarg1;
43068   {
43069     try {
43070       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43071     } catch (std::out_of_range& e) {
43072       {
43073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43074       };
43075     } catch (std::exception& e) {
43076       {
43077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43078       };
43079     } catch (Dali::DaliException e) {
43080       {
43081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43082       };
43083     } catch (...) {
43084       {
43085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43086       };
43087     }
43088   }
43089
43090   jresult = (void *)result;
43091   return jresult;
43092 }
43093
43094
43095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43096   int jresult ;
43097   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43098   Dali::AlphaFunction::BuiltinFunction result;
43099
43100   arg1 = (Dali::AlphaFunction *)jarg1;
43101   {
43102     try {
43103       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43104     } catch (std::out_of_range& e) {
43105       {
43106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43107       };
43108     } catch (std::exception& e) {
43109       {
43110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43111       };
43112     } catch (Dali::DaliException e) {
43113       {
43114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43115       };
43116     } catch (...) {
43117       {
43118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43119       };
43120     }
43121   }
43122
43123   jresult = (int)result;
43124   return jresult;
43125 }
43126
43127
43128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43129   int jresult ;
43130   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43131   Dali::AlphaFunction::Mode result;
43132
43133   arg1 = (Dali::AlphaFunction *)jarg1;
43134   {
43135     try {
43136       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43137     } catch (std::out_of_range& e) {
43138       {
43139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43140       };
43141     } catch (std::exception& e) {
43142       {
43143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43144       };
43145     } catch (Dali::DaliException e) {
43146       {
43147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43148       };
43149     } catch (...) {
43150       {
43151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43152       };
43153     }
43154   }
43155
43156   jresult = (int)result;
43157   return jresult;
43158 }
43159
43160
43161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43162   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43163
43164   arg1 = (Dali::AlphaFunction *)jarg1;
43165   {
43166     try {
43167       delete arg1;
43168     } catch (std::out_of_range& e) {
43169       {
43170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43171       };
43172     } catch (std::exception& e) {
43173       {
43174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43175       };
43176     } catch (Dali::DaliException e) {
43177       {
43178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43179       };
43180     } catch (...) {
43181       {
43182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43183       };
43184     }
43185   }
43186
43187 }
43188
43189
43190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43191   void * jresult ;
43192   Dali::KeyFrames result;
43193
43194   {
43195     try {
43196       result = Dali::KeyFrames::New();
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_KeyFrames_DownCast(void * jarg1) {
43222   void * jresult ;
43223   Dali::BaseHandle arg1 ;
43224   Dali::BaseHandle *argp1 ;
43225   Dali::KeyFrames result;
43226
43227   argp1 = (Dali::BaseHandle *)jarg1;
43228   if (!argp1) {
43229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43230     return 0;
43231   }
43232   arg1 = *argp1;
43233   {
43234     try {
43235       result = Dali::KeyFrames::DownCast(arg1);
43236     } catch (std::out_of_range& e) {
43237       {
43238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43239       };
43240     } catch (std::exception& e) {
43241       {
43242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43243       };
43244     } catch (Dali::DaliException e) {
43245       {
43246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43247       };
43248     } catch (...) {
43249       {
43250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43251       };
43252     }
43253   }
43254
43255   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43256   return jresult;
43257 }
43258
43259
43260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43261   void * jresult ;
43262   Dali::KeyFrames *result = 0 ;
43263
43264   {
43265     try {
43266       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43267     } catch (std::out_of_range& e) {
43268       {
43269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43270       };
43271     } catch (std::exception& e) {
43272       {
43273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43274       };
43275     } catch (Dali::DaliException e) {
43276       {
43277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43278       };
43279     } catch (...) {
43280       {
43281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43282       };
43283     }
43284   }
43285
43286   jresult = (void *)result;
43287   return jresult;
43288 }
43289
43290
43291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43292   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43293
43294   arg1 = (Dali::KeyFrames *)jarg1;
43295   {
43296     try {
43297       delete arg1;
43298     } catch (std::out_of_range& e) {
43299       {
43300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43301       };
43302     } catch (std::exception& e) {
43303       {
43304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43305       };
43306     } catch (Dali::DaliException e) {
43307       {
43308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43309       };
43310     } catch (...) {
43311       {
43312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43313       };
43314     }
43315   }
43316
43317 }
43318
43319
43320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43321   void * jresult ;
43322   Dali::KeyFrames *arg1 = 0 ;
43323   Dali::KeyFrames *result = 0 ;
43324
43325   arg1 = (Dali::KeyFrames *)jarg1;
43326   if (!arg1) {
43327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43328     return 0;
43329   }
43330   {
43331     try {
43332       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
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 void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43358   void * jresult ;
43359   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43360   Dali::KeyFrames *arg2 = 0 ;
43361   Dali::KeyFrames *result = 0 ;
43362
43363   arg1 = (Dali::KeyFrames *)jarg1;
43364   arg2 = (Dali::KeyFrames *)jarg2;
43365   if (!arg2) {
43366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43367     return 0;
43368   }
43369   {
43370     try {
43371       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43372     } catch (std::out_of_range& e) {
43373       {
43374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43375       };
43376     } catch (std::exception& e) {
43377       {
43378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43379       };
43380     } catch (Dali::DaliException e) {
43381       {
43382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43383       };
43384     } catch (...) {
43385       {
43386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43387       };
43388     }
43389   }
43390
43391   jresult = (void *)result;
43392   return jresult;
43393 }
43394
43395
43396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43397   int jresult ;
43398   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43399   Dali::Property::Type result;
43400
43401   arg1 = (Dali::KeyFrames *)jarg1;
43402   {
43403     try {
43404       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43405     } catch (std::out_of_range& e) {
43406       {
43407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43408       };
43409     } catch (std::exception& e) {
43410       {
43411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43412       };
43413     } catch (Dali::DaliException e) {
43414       {
43415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43416       };
43417     } catch (...) {
43418       {
43419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43420       };
43421     }
43422   }
43423
43424   jresult = (int)result;
43425   return jresult;
43426 }
43427
43428
43429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43430   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43431   float arg2 ;
43432   Dali::Property::Value arg3 ;
43433   Dali::Property::Value *argp3 ;
43434
43435   arg1 = (Dali::KeyFrames *)jarg1;
43436   arg2 = (float)jarg2;
43437   argp3 = (Dali::Property::Value *)jarg3;
43438   if (!argp3) {
43439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43440     return ;
43441   }
43442   arg3 = *argp3;
43443   {
43444     try {
43445       (arg1)->Add(arg2,arg3);
43446     } catch (std::out_of_range& e) {
43447       {
43448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43449       };
43450     } catch (std::exception& e) {
43451       {
43452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43453       };
43454     } catch (Dali::DaliException e) {
43455       {
43456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43457       };
43458     } catch (...) {
43459       {
43460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43461       };
43462     }
43463   }
43464
43465 }
43466
43467
43468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43469   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43470   float arg2 ;
43471   Dali::Property::Value arg3 ;
43472   Dali::AlphaFunction arg4 ;
43473   Dali::Property::Value *argp3 ;
43474   Dali::AlphaFunction *argp4 ;
43475
43476   arg1 = (Dali::KeyFrames *)jarg1;
43477   arg2 = (float)jarg2;
43478   argp3 = (Dali::Property::Value *)jarg3;
43479   if (!argp3) {
43480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43481     return ;
43482   }
43483   arg3 = *argp3;
43484   argp4 = (Dali::AlphaFunction *)jarg4;
43485   if (!argp4) {
43486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43487     return ;
43488   }
43489   arg4 = *argp4;
43490   {
43491     try {
43492       (arg1)->Add(arg2,arg3,arg4);
43493     } catch (std::out_of_range& e) {
43494       {
43495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43496       };
43497     } catch (std::exception& e) {
43498       {
43499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43500       };
43501     } catch (Dali::DaliException e) {
43502       {
43503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43504       };
43505     } catch (...) {
43506       {
43507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43508       };
43509     }
43510   }
43511
43512 }
43513
43514
43515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43516   int jresult ;
43517   int result;
43518
43519   result = (int)Dali::Path::Property::POINTS;
43520   jresult = (int)result;
43521   return jresult;
43522 }
43523
43524
43525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43526   int jresult ;
43527   int result;
43528
43529   result = (int)Dali::Path::Property::CONTROL_POINTS;
43530   jresult = (int)result;
43531   return jresult;
43532 }
43533
43534
43535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43536   void * jresult ;
43537   Dali::Path::Property *result = 0 ;
43538
43539   {
43540     try {
43541       result = (Dali::Path::Property *)new Dali::Path::Property();
43542     } catch (std::out_of_range& e) {
43543       {
43544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43545       };
43546     } catch (std::exception& e) {
43547       {
43548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43549       };
43550     } catch (Dali::DaliException e) {
43551       {
43552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43553       };
43554     } catch (...) {
43555       {
43556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43557       };
43558     }
43559   }
43560
43561   jresult = (void *)result;
43562   return jresult;
43563 }
43564
43565
43566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43567   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43568
43569   arg1 = (Dali::Path::Property *)jarg1;
43570   {
43571     try {
43572       delete arg1;
43573     } catch (std::out_of_range& e) {
43574       {
43575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43576       };
43577     } catch (std::exception& e) {
43578       {
43579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43580       };
43581     } catch (Dali::DaliException e) {
43582       {
43583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43584       };
43585     } catch (...) {
43586       {
43587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43588       };
43589     }
43590   }
43591
43592 }
43593
43594
43595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43596   void * jresult ;
43597   Dali::Path result;
43598
43599   {
43600     try {
43601       result = Dali::Path::New();
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_Path_DownCast(void * jarg1) {
43627   void * jresult ;
43628   Dali::BaseHandle arg1 ;
43629   Dali::BaseHandle *argp1 ;
43630   Dali::Path result;
43631
43632   argp1 = (Dali::BaseHandle *)jarg1;
43633   if (!argp1) {
43634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43635     return 0;
43636   }
43637   arg1 = *argp1;
43638   {
43639     try {
43640       result = Dali::Path::DownCast(arg1);
43641     } catch (std::out_of_range& e) {
43642       {
43643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43644       };
43645     } catch (std::exception& e) {
43646       {
43647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43648       };
43649     } catch (Dali::DaliException e) {
43650       {
43651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43652       };
43653     } catch (...) {
43654       {
43655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43656       };
43657     }
43658   }
43659
43660   jresult = new Dali::Path((const Dali::Path &)result);
43661   return jresult;
43662 }
43663
43664
43665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43666   void * jresult ;
43667   Dali::Path *result = 0 ;
43668
43669   {
43670     try {
43671       result = (Dali::Path *)new Dali::Path();
43672     } catch (std::out_of_range& e) {
43673       {
43674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43675       };
43676     } catch (std::exception& e) {
43677       {
43678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43679       };
43680     } catch (Dali::DaliException e) {
43681       {
43682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43683       };
43684     } catch (...) {
43685       {
43686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43687       };
43688     }
43689   }
43690
43691   jresult = (void *)result;
43692   return jresult;
43693 }
43694
43695
43696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43697   Dali::Path *arg1 = (Dali::Path *) 0 ;
43698
43699   arg1 = (Dali::Path *)jarg1;
43700   {
43701     try {
43702       delete arg1;
43703     } catch (std::out_of_range& e) {
43704       {
43705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43706       };
43707     } catch (std::exception& e) {
43708       {
43709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43710       };
43711     } catch (Dali::DaliException e) {
43712       {
43713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43714       };
43715     } catch (...) {
43716       {
43717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43718       };
43719     }
43720   }
43721
43722 }
43723
43724
43725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43726   void * jresult ;
43727   Dali::Path *arg1 = 0 ;
43728   Dali::Path *result = 0 ;
43729
43730   arg1 = (Dali::Path *)jarg1;
43731   if (!arg1) {
43732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43733     return 0;
43734   }
43735   {
43736     try {
43737       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
43763   void * jresult ;
43764   Dali::Path *arg1 = (Dali::Path *) 0 ;
43765   Dali::Path *arg2 = 0 ;
43766   Dali::Path *result = 0 ;
43767
43768   arg1 = (Dali::Path *)jarg1;
43769   arg2 = (Dali::Path *)jarg2;
43770   if (!arg2) {
43771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43772     return 0;
43773   }
43774   {
43775     try {
43776       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43777     } catch (std::out_of_range& e) {
43778       {
43779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43780       };
43781     } catch (std::exception& e) {
43782       {
43783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43784       };
43785     } catch (Dali::DaliException e) {
43786       {
43787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43788       };
43789     } catch (...) {
43790       {
43791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43792       };
43793     }
43794   }
43795
43796   jresult = (void *)result;
43797   return jresult;
43798 }
43799
43800
43801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43802   Dali::Path *arg1 = (Dali::Path *) 0 ;
43803   Dali::Vector3 *arg2 = 0 ;
43804
43805   arg1 = (Dali::Path *)jarg1;
43806   arg2 = (Dali::Vector3 *)jarg2;
43807   if (!arg2) {
43808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43809     return ;
43810   }
43811   {
43812     try {
43813       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43814     } catch (std::out_of_range& e) {
43815       {
43816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43817       };
43818     } catch (std::exception& e) {
43819       {
43820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43821       };
43822     } catch (Dali::DaliException e) {
43823       {
43824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43825       };
43826     } catch (...) {
43827       {
43828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43829       };
43830     }
43831   }
43832
43833 }
43834
43835
43836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43837   Dali::Path *arg1 = (Dali::Path *) 0 ;
43838   Dali::Vector3 *arg2 = 0 ;
43839
43840   arg1 = (Dali::Path *)jarg1;
43841   arg2 = (Dali::Vector3 *)jarg2;
43842   if (!arg2) {
43843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43844     return ;
43845   }
43846   {
43847     try {
43848       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43849     } catch (std::out_of_range& e) {
43850       {
43851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43852       };
43853     } catch (std::exception& e) {
43854       {
43855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43856       };
43857     } catch (Dali::DaliException e) {
43858       {
43859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43860       };
43861     } catch (...) {
43862       {
43863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43864       };
43865     }
43866   }
43867
43868 }
43869
43870
43871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43872   Dali::Path *arg1 = (Dali::Path *) 0 ;
43873   float arg2 ;
43874
43875   arg1 = (Dali::Path *)jarg1;
43876   arg2 = (float)jarg2;
43877   {
43878     try {
43879       (arg1)->GenerateControlPoints(arg2);
43880     } catch (std::out_of_range& e) {
43881       {
43882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43883       };
43884     } catch (std::exception& e) {
43885       {
43886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43887       };
43888     } catch (Dali::DaliException e) {
43889       {
43890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43891       };
43892     } catch (...) {
43893       {
43894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43895       };
43896     }
43897   }
43898
43899 }
43900
43901
43902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43903   Dali::Path *arg1 = (Dali::Path *) 0 ;
43904   float arg2 ;
43905   Dali::Vector3 *arg3 = 0 ;
43906   Dali::Vector3 *arg4 = 0 ;
43907
43908   arg1 = (Dali::Path *)jarg1;
43909   arg2 = (float)jarg2;
43910   arg3 = (Dali::Vector3 *)jarg3;
43911   if (!arg3) {
43912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43913     return ;
43914   }
43915   arg4 = (Dali::Vector3 *)jarg4;
43916   if (!arg4) {
43917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43918     return ;
43919   }
43920   {
43921     try {
43922       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43923     } catch (std::out_of_range& e) {
43924       {
43925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43926       };
43927     } catch (std::exception& e) {
43928       {
43929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43930       };
43931     } catch (Dali::DaliException e) {
43932       {
43933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43934       };
43935     } catch (...) {
43936       {
43937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43938       };
43939     }
43940   }
43941
43942 }
43943
43944
43945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43946   void * jresult ;
43947   Dali::Path *arg1 = (Dali::Path *) 0 ;
43948   size_t arg2 ;
43949   Dali::Vector3 *result = 0 ;
43950
43951   arg1 = (Dali::Path *)jarg1;
43952   arg2 = (size_t)jarg2;
43953   {
43954     try {
43955       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43956     } catch (std::out_of_range& e) {
43957       {
43958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43959       };
43960     } catch (std::exception& e) {
43961       {
43962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43963       };
43964     } catch (Dali::DaliException e) {
43965       {
43966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43967       };
43968     } catch (...) {
43969       {
43970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43971       };
43972     }
43973   }
43974
43975   jresult = (void *)result;
43976   return jresult;
43977 }
43978
43979
43980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43981   void * jresult ;
43982   Dali::Path *arg1 = (Dali::Path *) 0 ;
43983   size_t arg2 ;
43984   Dali::Vector3 *result = 0 ;
43985
43986   arg1 = (Dali::Path *)jarg1;
43987   arg2 = (size_t)jarg2;
43988   {
43989     try {
43990       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43991     } catch (std::out_of_range& e) {
43992       {
43993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43994       };
43995     } catch (std::exception& e) {
43996       {
43997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43998       };
43999     } catch (Dali::DaliException e) {
44000       {
44001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44002       };
44003     } catch (...) {
44004       {
44005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44006       };
44007     }
44008   }
44009
44010   jresult = (void *)result;
44011   return jresult;
44012 }
44013
44014
44015 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44016   unsigned long jresult ;
44017   Dali::Path *arg1 = (Dali::Path *) 0 ;
44018   size_t result;
44019
44020   arg1 = (Dali::Path *)jarg1;
44021   {
44022     try {
44023       result = ((Dali::Path const *)arg1)->GetPointCount();
44024     } catch (std::out_of_range& e) {
44025       {
44026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44027       };
44028     } catch (std::exception& e) {
44029       {
44030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44031       };
44032     } catch (Dali::DaliException e) {
44033       {
44034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44035       };
44036     } catch (...) {
44037       {
44038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44039       };
44040     }
44041   }
44042
44043   jresult = (unsigned long)result;
44044   return jresult;
44045 }
44046
44047
44048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44049   void * jresult ;
44050   float arg1 ;
44051   Dali::TimePeriod *result = 0 ;
44052
44053   arg1 = (float)jarg1;
44054   {
44055     try {
44056       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44057     } catch (std::out_of_range& e) {
44058       {
44059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44060       };
44061     } catch (std::exception& e) {
44062       {
44063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44064       };
44065     } catch (Dali::DaliException e) {
44066       {
44067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44068       };
44069     } catch (...) {
44070       {
44071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44072       };
44073     }
44074   }
44075
44076   jresult = (void *)result;
44077   return jresult;
44078 }
44079
44080
44081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44082   void * jresult ;
44083   float arg1 ;
44084   float arg2 ;
44085   Dali::TimePeriod *result = 0 ;
44086
44087   arg1 = (float)jarg1;
44088   arg2 = (float)jarg2;
44089   {
44090     try {
44091       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44092     } catch (std::out_of_range& e) {
44093       {
44094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44095       };
44096     } catch (std::exception& e) {
44097       {
44098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44099       };
44100     } catch (Dali::DaliException e) {
44101       {
44102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44103       };
44104     } catch (...) {
44105       {
44106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44107       };
44108     }
44109   }
44110
44111   jresult = (void *)result;
44112   return jresult;
44113 }
44114
44115
44116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44117   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44118
44119   arg1 = (Dali::TimePeriod *)jarg1;
44120   {
44121     try {
44122       delete arg1;
44123     } catch (std::out_of_range& e) {
44124       {
44125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44126       };
44127     } catch (std::exception& e) {
44128       {
44129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44130       };
44131     } catch (Dali::DaliException e) {
44132       {
44133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44134       };
44135     } catch (...) {
44136       {
44137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44138       };
44139     }
44140   }
44141
44142 }
44143
44144
44145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44146   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44147   float arg2 ;
44148
44149   arg1 = (Dali::TimePeriod *)jarg1;
44150   arg2 = (float)jarg2;
44151   if (arg1) (arg1)->delaySeconds = arg2;
44152 }
44153
44154
44155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44156   float jresult ;
44157   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44158   float result;
44159
44160   arg1 = (Dali::TimePeriod *)jarg1;
44161   result = (float) ((arg1)->delaySeconds);
44162   jresult = result;
44163   return jresult;
44164 }
44165
44166
44167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44168   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44169   float arg2 ;
44170
44171   arg1 = (Dali::TimePeriod *)jarg1;
44172   arg2 = (float)jarg2;
44173   if (arg1) (arg1)->durationSeconds = arg2;
44174 }
44175
44176
44177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44178   float jresult ;
44179   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44180   float result;
44181
44182   arg1 = (Dali::TimePeriod *)jarg1;
44183   result = (float) ((arg1)->durationSeconds);
44184   jresult = result;
44185   return jresult;
44186 }
44187
44188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44189   int jresult ;
44190   int result;
44191
44192   result = (int)Dali::LinearConstrainer::Property::VALUE;
44193   jresult = (int)result;
44194   return jresult;
44195 }
44196
44197
44198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44199   int jresult ;
44200   int result;
44201
44202   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44203   jresult = (int)result;
44204   return jresult;
44205 }
44206
44207
44208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44209   void * jresult ;
44210   Dali::LinearConstrainer::Property *result = 0 ;
44211
44212   {
44213     try {
44214       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44215     } catch (std::out_of_range& e) {
44216       {
44217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44218       };
44219     } catch (std::exception& e) {
44220       {
44221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44222       };
44223     } catch (Dali::DaliException e) {
44224       {
44225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44226       };
44227     } catch (...) {
44228       {
44229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44230       };
44231     }
44232   }
44233
44234   jresult = (void *)result;
44235   return jresult;
44236 }
44237
44238
44239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44240   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44241
44242   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44243   {
44244     try {
44245       delete arg1;
44246     } catch (std::out_of_range& e) {
44247       {
44248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44249       };
44250     } catch (std::exception& e) {
44251       {
44252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44253       };
44254     } catch (Dali::DaliException e) {
44255       {
44256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44257       };
44258     } catch (...) {
44259       {
44260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44261       };
44262     }
44263   }
44264
44265 }
44266
44267
44268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44269   void * jresult ;
44270   Dali::LinearConstrainer result;
44271
44272   {
44273     try {
44274       result = Dali::LinearConstrainer::New();
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_LinearConstrainer_DownCast(void * jarg1) {
44300   void * jresult ;
44301   Dali::BaseHandle arg1 ;
44302   Dali::BaseHandle *argp1 ;
44303   Dali::LinearConstrainer result;
44304
44305   argp1 = (Dali::BaseHandle *)jarg1;
44306   if (!argp1) {
44307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44308     return 0;
44309   }
44310   arg1 = *argp1;
44311   {
44312     try {
44313       result = Dali::LinearConstrainer::DownCast(arg1);
44314     } catch (std::out_of_range& e) {
44315       {
44316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44317       };
44318     } catch (std::exception& e) {
44319       {
44320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44321       };
44322     } catch (Dali::DaliException e) {
44323       {
44324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44325       };
44326     } catch (...) {
44327       {
44328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44329       };
44330     }
44331   }
44332
44333   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44334   return jresult;
44335 }
44336
44337
44338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44339   void * jresult ;
44340   Dali::LinearConstrainer *result = 0 ;
44341
44342   {
44343     try {
44344       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44345     } catch (std::out_of_range& e) {
44346       {
44347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44348       };
44349     } catch (std::exception& e) {
44350       {
44351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44352       };
44353     } catch (Dali::DaliException e) {
44354       {
44355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44356       };
44357     } catch (...) {
44358       {
44359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44360       };
44361     }
44362   }
44363
44364   jresult = (void *)result;
44365   return jresult;
44366 }
44367
44368
44369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44370   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44371
44372   arg1 = (Dali::LinearConstrainer *)jarg1;
44373   {
44374     try {
44375       delete arg1;
44376     } catch (std::out_of_range& e) {
44377       {
44378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44379       };
44380     } catch (std::exception& e) {
44381       {
44382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44383       };
44384     } catch (Dali::DaliException e) {
44385       {
44386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44387       };
44388     } catch (...) {
44389       {
44390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44391       };
44392     }
44393   }
44394
44395 }
44396
44397
44398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44399   void * jresult ;
44400   Dali::LinearConstrainer *arg1 = 0 ;
44401   Dali::LinearConstrainer *result = 0 ;
44402
44403   arg1 = (Dali::LinearConstrainer *)jarg1;
44404   if (!arg1) {
44405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44406     return 0;
44407   }
44408   {
44409     try {
44410       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
44436   void * jresult ;
44437   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44438   Dali::LinearConstrainer *arg2 = 0 ;
44439   Dali::LinearConstrainer *result = 0 ;
44440
44441   arg1 = (Dali::LinearConstrainer *)jarg1;
44442   arg2 = (Dali::LinearConstrainer *)jarg2;
44443   if (!arg2) {
44444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44445     return 0;
44446   }
44447   {
44448     try {
44449       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44450     } catch (std::out_of_range& e) {
44451       {
44452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44453       };
44454     } catch (std::exception& e) {
44455       {
44456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44457       };
44458     } catch (Dali::DaliException e) {
44459       {
44460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44461       };
44462     } catch (...) {
44463       {
44464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44465       };
44466     }
44467   }
44468
44469   jresult = (void *)result;
44470   return jresult;
44471 }
44472
44473
44474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44475   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44476   SwigValueWrapper< Dali::Property > arg2 ;
44477   SwigValueWrapper< Dali::Property > arg3 ;
44478   Dali::Vector2 *arg4 = 0 ;
44479   Dali::Vector2 *arg5 = 0 ;
44480   Dali::Property *argp2 ;
44481   Dali::Property *argp3 ;
44482
44483   arg1 = (Dali::LinearConstrainer *)jarg1;
44484   argp2 = (Dali::Property *)jarg2;
44485   if (!argp2) {
44486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44487     return ;
44488   }
44489   arg2 = *argp2;
44490   argp3 = (Dali::Property *)jarg3;
44491   if (!argp3) {
44492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44493     return ;
44494   }
44495   arg3 = *argp3;
44496   arg4 = (Dali::Vector2 *)jarg4;
44497   if (!arg4) {
44498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44499     return ;
44500   }
44501   arg5 = (Dali::Vector2 *)jarg5;
44502   if (!arg5) {
44503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44504     return ;
44505   }
44506   {
44507     try {
44508       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44509     } catch (std::out_of_range& e) {
44510       {
44511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44512       };
44513     } catch (std::exception& e) {
44514       {
44515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44516       };
44517     } catch (Dali::DaliException e) {
44518       {
44519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44520       };
44521     } catch (...) {
44522       {
44523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44524       };
44525     }
44526   }
44527
44528 }
44529
44530
44531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44532   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44533   SwigValueWrapper< Dali::Property > arg2 ;
44534   SwigValueWrapper< Dali::Property > arg3 ;
44535   Dali::Vector2 *arg4 = 0 ;
44536   Dali::Property *argp2 ;
44537   Dali::Property *argp3 ;
44538
44539   arg1 = (Dali::LinearConstrainer *)jarg1;
44540   argp2 = (Dali::Property *)jarg2;
44541   if (!argp2) {
44542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44543     return ;
44544   }
44545   arg2 = *argp2;
44546   argp3 = (Dali::Property *)jarg3;
44547   if (!argp3) {
44548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44549     return ;
44550   }
44551   arg3 = *argp3;
44552   arg4 = (Dali::Vector2 *)jarg4;
44553   if (!arg4) {
44554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44555     return ;
44556   }
44557   {
44558     try {
44559       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44560     } catch (std::out_of_range& e) {
44561       {
44562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44563       };
44564     } catch (std::exception& e) {
44565       {
44566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44567       };
44568     } catch (Dali::DaliException e) {
44569       {
44570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44571       };
44572     } catch (...) {
44573       {
44574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44575       };
44576     }
44577   }
44578
44579 }
44580
44581
44582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44583   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44584   Dali::Handle *arg2 = 0 ;
44585
44586   arg1 = (Dali::LinearConstrainer *)jarg1;
44587   arg2 = (Dali::Handle *)jarg2;
44588   if (!arg2) {
44589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44590     return ;
44591   }
44592   {
44593     try {
44594       (arg1)->Remove(*arg2);
44595     } catch (std::out_of_range& e) {
44596       {
44597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44598       };
44599     } catch (std::exception& e) {
44600       {
44601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44602       };
44603     } catch (Dali::DaliException e) {
44604       {
44605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44606       };
44607     } catch (...) {
44608       {
44609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44610       };
44611     }
44612   }
44613
44614 }
44615
44616
44617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44618   int jresult ;
44619   int result;
44620
44621   result = (int)Dali::PathConstrainer::Property::FORWARD;
44622   jresult = (int)result;
44623   return jresult;
44624 }
44625
44626
44627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44628   int jresult ;
44629   int result;
44630
44631   result = (int)Dali::PathConstrainer::Property::POINTS;
44632   jresult = (int)result;
44633   return jresult;
44634 }
44635
44636
44637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44638   int jresult ;
44639   int result;
44640
44641   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44642   jresult = (int)result;
44643   return jresult;
44644 }
44645
44646
44647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44648   void * jresult ;
44649   Dali::PathConstrainer::Property *result = 0 ;
44650
44651   {
44652     try {
44653       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44654     } catch (std::out_of_range& e) {
44655       {
44656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44657       };
44658     } catch (std::exception& e) {
44659       {
44660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44661       };
44662     } catch (Dali::DaliException e) {
44663       {
44664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44665       };
44666     } catch (...) {
44667       {
44668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44669       };
44670     }
44671   }
44672
44673   jresult = (void *)result;
44674   return jresult;
44675 }
44676
44677
44678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44679   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44680
44681   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44682   {
44683     try {
44684       delete arg1;
44685     } catch (std::out_of_range& e) {
44686       {
44687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44688       };
44689     } catch (std::exception& e) {
44690       {
44691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44692       };
44693     } catch (Dali::DaliException e) {
44694       {
44695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44696       };
44697     } catch (...) {
44698       {
44699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44700       };
44701     }
44702   }
44703
44704 }
44705
44706
44707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44708   void * jresult ;
44709   Dali::PathConstrainer result;
44710
44711   {
44712     try {
44713       result = Dali::PathConstrainer::New();
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_PathConstrainer_DownCast(void * jarg1) {
44739   void * jresult ;
44740   Dali::BaseHandle arg1 ;
44741   Dali::BaseHandle *argp1 ;
44742   Dali::PathConstrainer result;
44743
44744   argp1 = (Dali::BaseHandle *)jarg1;
44745   if (!argp1) {
44746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44747     return 0;
44748   }
44749   arg1 = *argp1;
44750   {
44751     try {
44752       result = Dali::PathConstrainer::DownCast(arg1);
44753     } catch (std::out_of_range& e) {
44754       {
44755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44756       };
44757     } catch (std::exception& e) {
44758       {
44759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44760       };
44761     } catch (Dali::DaliException e) {
44762       {
44763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44764       };
44765     } catch (...) {
44766       {
44767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44768       };
44769     }
44770   }
44771
44772   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44773   return jresult;
44774 }
44775
44776
44777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44778   void * jresult ;
44779   Dali::PathConstrainer *result = 0 ;
44780
44781   {
44782     try {
44783       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44784     } catch (std::out_of_range& e) {
44785       {
44786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44787       };
44788     } catch (std::exception& e) {
44789       {
44790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44791       };
44792     } catch (Dali::DaliException e) {
44793       {
44794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44795       };
44796     } catch (...) {
44797       {
44798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44799       };
44800     }
44801   }
44802
44803   jresult = (void *)result;
44804   return jresult;
44805 }
44806
44807
44808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44809   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44810
44811   arg1 = (Dali::PathConstrainer *)jarg1;
44812   {
44813     try {
44814       delete arg1;
44815     } catch (std::out_of_range& e) {
44816       {
44817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44818       };
44819     } catch (std::exception& e) {
44820       {
44821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44822       };
44823     } catch (Dali::DaliException e) {
44824       {
44825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44826       };
44827     } catch (...) {
44828       {
44829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44830       };
44831     }
44832   }
44833
44834 }
44835
44836
44837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44838   void * jresult ;
44839   Dali::PathConstrainer *arg1 = 0 ;
44840   Dali::PathConstrainer *result = 0 ;
44841
44842   arg1 = (Dali::PathConstrainer *)jarg1;
44843   if (!arg1) {
44844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44845     return 0;
44846   }
44847   {
44848     try {
44849       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
44875   void * jresult ;
44876   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44877   Dali::PathConstrainer *arg2 = 0 ;
44878   Dali::PathConstrainer *result = 0 ;
44879
44880   arg1 = (Dali::PathConstrainer *)jarg1;
44881   arg2 = (Dali::PathConstrainer *)jarg2;
44882   if (!arg2) {
44883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44884     return 0;
44885   }
44886   {
44887     try {
44888       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44889     } catch (std::out_of_range& e) {
44890       {
44891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44892       };
44893     } catch (std::exception& e) {
44894       {
44895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44896       };
44897     } catch (Dali::DaliException e) {
44898       {
44899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44900       };
44901     } catch (...) {
44902       {
44903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44904       };
44905     }
44906   }
44907
44908   jresult = (void *)result;
44909   return jresult;
44910 }
44911
44912
44913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44914   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44915   SwigValueWrapper< Dali::Property > arg2 ;
44916   SwigValueWrapper< Dali::Property > arg3 ;
44917   Dali::Vector2 *arg4 = 0 ;
44918   Dali::Vector2 *arg5 = 0 ;
44919   Dali::Property *argp2 ;
44920   Dali::Property *argp3 ;
44921
44922   arg1 = (Dali::PathConstrainer *)jarg1;
44923   argp2 = (Dali::Property *)jarg2;
44924   if (!argp2) {
44925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44926     return ;
44927   }
44928   arg2 = *argp2;
44929   argp3 = (Dali::Property *)jarg3;
44930   if (!argp3) {
44931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44932     return ;
44933   }
44934   arg3 = *argp3;
44935   arg4 = (Dali::Vector2 *)jarg4;
44936   if (!arg4) {
44937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44938     return ;
44939   }
44940   arg5 = (Dali::Vector2 *)jarg5;
44941   if (!arg5) {
44942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44943     return ;
44944   }
44945   {
44946     try {
44947       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44948     } catch (std::out_of_range& e) {
44949       {
44950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44951       };
44952     } catch (std::exception& e) {
44953       {
44954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44955       };
44956     } catch (Dali::DaliException e) {
44957       {
44958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44959       };
44960     } catch (...) {
44961       {
44962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44963       };
44964     }
44965   }
44966
44967 }
44968
44969
44970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44971   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44972   SwigValueWrapper< Dali::Property > arg2 ;
44973   SwigValueWrapper< Dali::Property > arg3 ;
44974   Dali::Vector2 *arg4 = 0 ;
44975   Dali::Property *argp2 ;
44976   Dali::Property *argp3 ;
44977
44978   arg1 = (Dali::PathConstrainer *)jarg1;
44979   argp2 = (Dali::Property *)jarg2;
44980   if (!argp2) {
44981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44982     return ;
44983   }
44984   arg2 = *argp2;
44985   argp3 = (Dali::Property *)jarg3;
44986   if (!argp3) {
44987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44988     return ;
44989   }
44990   arg3 = *argp3;
44991   arg4 = (Dali::Vector2 *)jarg4;
44992   if (!arg4) {
44993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44994     return ;
44995   }
44996   {
44997     try {
44998       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44999     } catch (std::out_of_range& e) {
45000       {
45001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45002       };
45003     } catch (std::exception& e) {
45004       {
45005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45006       };
45007     } catch (Dali::DaliException e) {
45008       {
45009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45010       };
45011     } catch (...) {
45012       {
45013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45014       };
45015     }
45016   }
45017
45018 }
45019
45020
45021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45022   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45023   Dali::Handle *arg2 = 0 ;
45024
45025   arg1 = (Dali::PathConstrainer *)jarg1;
45026   arg2 = (Dali::Handle *)jarg2;
45027   if (!arg2) {
45028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45029     return ;
45030   }
45031   {
45032     try {
45033       (arg1)->Remove(*arg2);
45034     } catch (std::out_of_range& e) {
45035       {
45036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45037       };
45038     } catch (std::exception& e) {
45039       {
45040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45041       };
45042     } catch (Dali::DaliException e) {
45043       {
45044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45045       };
45046     } catch (...) {
45047       {
45048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45049       };
45050     }
45051   }
45052
45053 }
45054
45055
45056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45057   int jresult ;
45058   Dali::FittingMode::Type result;
45059
45060   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45061   jresult = (int)result;
45062   return jresult;
45063 }
45064
45065
45066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45067   int jresult ;
45068   Dali::SamplingMode::Type result;
45069
45070   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45071   jresult = (int)result;
45072   return jresult;
45073 }
45074
45075
45076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45077   void * jresult ;
45078   Dali::BufferImage *result = 0 ;
45079
45080   {
45081     try {
45082       result = (Dali::BufferImage *)new Dali::BufferImage();
45083     } catch (std::out_of_range& e) {
45084       {
45085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45086       };
45087     } catch (std::exception& e) {
45088       {
45089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45090       };
45091     } catch (Dali::DaliException e) {
45092       {
45093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45094       };
45095     } catch (...) {
45096       {
45097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45098       };
45099     }
45100   }
45101
45102   jresult = (void *)result;
45103   return jresult;
45104 }
45105
45106
45107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45108   void * jresult ;
45109   unsigned int arg1 ;
45110   unsigned int arg2 ;
45111   Dali::Pixel::Format arg3 ;
45112   Dali::BufferImage result;
45113
45114   arg1 = (unsigned int)jarg1;
45115   arg2 = (unsigned int)jarg2;
45116   arg3 = (Dali::Pixel::Format)jarg3;
45117   {
45118     try {
45119       result = Dali::BufferImage::New(arg1,arg2,arg3);
45120     } catch (std::out_of_range& e) {
45121       {
45122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45123       };
45124     } catch (std::exception& e) {
45125       {
45126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45127       };
45128     } catch (Dali::DaliException e) {
45129       {
45130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45131       };
45132     } catch (...) {
45133       {
45134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45135       };
45136     }
45137   }
45138
45139   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45140   return jresult;
45141 }
45142
45143
45144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45145   void * jresult ;
45146   unsigned int arg1 ;
45147   unsigned int arg2 ;
45148   Dali::BufferImage result;
45149
45150   arg1 = (unsigned int)jarg1;
45151   arg2 = (unsigned int)jarg2;
45152   {
45153     try {
45154       result = Dali::BufferImage::New(arg1,arg2);
45155     } catch (std::out_of_range& e) {
45156       {
45157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45158       };
45159     } catch (std::exception& e) {
45160       {
45161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45162       };
45163     } catch (Dali::DaliException e) {
45164       {
45165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45166       };
45167     } catch (...) {
45168       {
45169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45170       };
45171     }
45172   }
45173
45174   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45175   return jresult;
45176 }
45177
45178
45179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45180   void * jresult ;
45181   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45182   unsigned int arg2 ;
45183   unsigned int arg3 ;
45184   Dali::Pixel::Format arg4 ;
45185   unsigned int arg5 ;
45186   Dali::BufferImage result;
45187
45188   arg1 = jarg1;
45189   arg2 = (unsigned int)jarg2;
45190   arg3 = (unsigned int)jarg3;
45191   arg4 = (Dali::Pixel::Format)jarg4;
45192   arg5 = (unsigned int)jarg5;
45193   {
45194     try {
45195       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45196     } catch (std::out_of_range& e) {
45197       {
45198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45199       };
45200     } catch (std::exception& e) {
45201       {
45202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45203       };
45204     } catch (Dali::DaliException e) {
45205       {
45206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45207       };
45208     } catch (...) {
45209       {
45210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45211       };
45212     }
45213   }
45214
45215   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45216
45217
45218   return jresult;
45219 }
45220
45221
45222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45223   void * jresult ;
45224   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45225   unsigned int arg2 ;
45226   unsigned int arg3 ;
45227   Dali::Pixel::Format arg4 ;
45228   Dali::BufferImage result;
45229
45230   arg1 = jarg1;
45231   arg2 = (unsigned int)jarg2;
45232   arg3 = (unsigned int)jarg3;
45233   arg4 = (Dali::Pixel::Format)jarg4;
45234   {
45235     try {
45236       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
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_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45264   void * jresult ;
45265   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45266   unsigned int arg2 ;
45267   unsigned int arg3 ;
45268   Dali::BufferImage result;
45269
45270   arg1 = jarg1;
45271   arg2 = (unsigned int)jarg2;
45272   arg3 = (unsigned int)jarg3;
45273   {
45274     try {
45275       result = Dali::BufferImage::New(arg1,arg2,arg3);
45276     } catch (std::out_of_range& e) {
45277       {
45278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45279       };
45280     } catch (std::exception& e) {
45281       {
45282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45283       };
45284     } catch (Dali::DaliException e) {
45285       {
45286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45287       };
45288     } catch (...) {
45289       {
45290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45291       };
45292     }
45293   }
45294
45295   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45296
45297
45298   return jresult;
45299 }
45300
45301
45302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45303   void * jresult ;
45304   Dali::BaseHandle arg1 ;
45305   Dali::BaseHandle *argp1 ;
45306   Dali::BufferImage result;
45307
45308   argp1 = (Dali::BaseHandle *)jarg1;
45309   if (!argp1) {
45310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45311     return 0;
45312   }
45313   arg1 = *argp1;
45314   {
45315     try {
45316       result = Dali::BufferImage::DownCast(arg1);
45317     } catch (std::out_of_range& e) {
45318       {
45319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45320       };
45321     } catch (std::exception& e) {
45322       {
45323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45324       };
45325     } catch (Dali::DaliException e) {
45326       {
45327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45328       };
45329     } catch (...) {
45330       {
45331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45332       };
45333     }
45334   }
45335
45336   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45337   return jresult;
45338 }
45339
45340
45341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45342   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45343
45344   arg1 = (Dali::BufferImage *)jarg1;
45345   {
45346     try {
45347       delete arg1;
45348     } catch (std::out_of_range& e) {
45349       {
45350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45351       };
45352     } catch (std::exception& e) {
45353       {
45354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45355       };
45356     } catch (Dali::DaliException e) {
45357       {
45358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45359       };
45360     } catch (...) {
45361       {
45362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45363       };
45364     }
45365   }
45366
45367 }
45368
45369
45370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45371   void * jresult ;
45372   Dali::BufferImage *arg1 = 0 ;
45373   Dali::BufferImage *result = 0 ;
45374
45375   arg1 = (Dali::BufferImage *)jarg1;
45376   if (!arg1) {
45377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45378     return 0;
45379   }
45380   {
45381     try {
45382       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
45408   void * jresult ;
45409   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45410   Dali::BufferImage *arg2 = 0 ;
45411   Dali::BufferImage *result = 0 ;
45412
45413   arg1 = (Dali::BufferImage *)jarg1;
45414   arg2 = (Dali::BufferImage *)jarg2;
45415   if (!arg2) {
45416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45417     return 0;
45418   }
45419   {
45420     try {
45421       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45422     } catch (std::out_of_range& e) {
45423       {
45424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45425       };
45426     } catch (std::exception& e) {
45427       {
45428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45429       };
45430     } catch (Dali::DaliException e) {
45431       {
45432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45433       };
45434     } catch (...) {
45435       {
45436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45437       };
45438     }
45439   }
45440
45441   jresult = (void *)result;
45442   return jresult;
45443 }
45444
45445
45446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45447   void * jresult ;
45448   Dali::BufferImage result;
45449
45450   {
45451     try {
45452       result = Dali::BufferImage::WHITE();
45453     } catch (std::out_of_range& e) {
45454       {
45455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45456       };
45457     } catch (std::exception& e) {
45458       {
45459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45460       };
45461     } catch (Dali::DaliException e) {
45462       {
45463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45464       };
45465     } catch (...) {
45466       {
45467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45468       };
45469     }
45470   }
45471
45472   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45473   return jresult;
45474 }
45475
45476
45477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45478   void * jresult ;
45479   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45480   Dali::PixelBuffer *result = 0 ;
45481
45482   arg1 = (Dali::BufferImage *)jarg1;
45483   {
45484     try {
45485       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45486     } catch (std::out_of_range& e) {
45487       {
45488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45489       };
45490     } catch (std::exception& e) {
45491       {
45492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45493       };
45494     } catch (Dali::DaliException e) {
45495       {
45496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45497       };
45498     } catch (...) {
45499       {
45500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45501       };
45502     }
45503   }
45504
45505   jresult = (void *)result;
45506   return jresult;
45507 }
45508
45509
45510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45511   unsigned int jresult ;
45512   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45513   unsigned int result;
45514
45515   arg1 = (Dali::BufferImage *)jarg1;
45516   {
45517     try {
45518       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45519     } catch (std::out_of_range& e) {
45520       {
45521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45522       };
45523     } catch (std::exception& e) {
45524       {
45525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45526       };
45527     } catch (Dali::DaliException e) {
45528       {
45529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45530       };
45531     } catch (...) {
45532       {
45533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45534       };
45535     }
45536   }
45537
45538   jresult = result;
45539   return jresult;
45540 }
45541
45542
45543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45544   unsigned int jresult ;
45545   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45546   unsigned int result;
45547
45548   arg1 = (Dali::BufferImage *)jarg1;
45549   {
45550     try {
45551       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45552     } catch (std::out_of_range& e) {
45553       {
45554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45555       };
45556     } catch (std::exception& e) {
45557       {
45558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45559       };
45560     } catch (Dali::DaliException e) {
45561       {
45562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45563       };
45564     } catch (...) {
45565       {
45566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45567       };
45568     }
45569   }
45570
45571   jresult = result;
45572   return jresult;
45573 }
45574
45575
45576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45577   int jresult ;
45578   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45579   Dali::Pixel::Format result;
45580
45581   arg1 = (Dali::BufferImage *)jarg1;
45582   {
45583     try {
45584       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45585     } catch (std::out_of_range& e) {
45586       {
45587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45588       };
45589     } catch (std::exception& e) {
45590       {
45591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45592       };
45593     } catch (Dali::DaliException e) {
45594       {
45595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45596       };
45597     } catch (...) {
45598       {
45599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45600       };
45601     }
45602   }
45603
45604   jresult = (int)result;
45605   return jresult;
45606 }
45607
45608
45609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45610   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45611
45612   arg1 = (Dali::BufferImage *)jarg1;
45613   {
45614     try {
45615       (arg1)->Update();
45616     } catch (std::out_of_range& e) {
45617       {
45618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45619       };
45620     } catch (std::exception& e) {
45621       {
45622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45623       };
45624     } catch (Dali::DaliException e) {
45625       {
45626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45627       };
45628     } catch (...) {
45629       {
45630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45631       };
45632     }
45633   }
45634
45635 }
45636
45637
45638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45639   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45640   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45641   Dali::RectArea *argp2 ;
45642
45643   arg1 = (Dali::BufferImage *)jarg1;
45644   argp2 = (Dali::RectArea *)jarg2;
45645   if (!argp2) {
45646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45647     return ;
45648   }
45649   arg2 = *argp2;
45650   {
45651     try {
45652       (arg1)->Update(arg2);
45653     } catch (std::out_of_range& e) {
45654       {
45655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45656       };
45657     } catch (std::exception& e) {
45658       {
45659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45660       };
45661     } catch (Dali::DaliException e) {
45662       {
45663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45664       };
45665     } catch (...) {
45666       {
45667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45668       };
45669     }
45670   }
45671
45672 }
45673
45674
45675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45676   unsigned int jresult ;
45677   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45678   bool result;
45679
45680   arg1 = (Dali::BufferImage *)jarg1;
45681   {
45682     try {
45683       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45684     } catch (std::out_of_range& e) {
45685       {
45686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45687       };
45688     } catch (std::exception& e) {
45689       {
45690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45691       };
45692     } catch (Dali::DaliException e) {
45693       {
45694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45695       };
45696     } catch (...) {
45697       {
45698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45699       };
45700     }
45701   }
45702
45703   jresult = result;
45704   return jresult;
45705 }
45706
45707
45708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45709   void * jresult ;
45710   Dali::EncodedBufferImage *result = 0 ;
45711
45712   {
45713     try {
45714       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45715     } catch (std::out_of_range& e) {
45716       {
45717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45718       };
45719     } catch (std::exception& e) {
45720       {
45721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45722       };
45723     } catch (Dali::DaliException e) {
45724       {
45725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45726       };
45727     } catch (...) {
45728       {
45729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45730       };
45731     }
45732   }
45733
45734   jresult = (void *)result;
45735   return jresult;
45736 }
45737
45738
45739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45740   void * jresult ;
45741   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45742   std::size_t arg2 ;
45743   Dali::EncodedBufferImage result;
45744
45745   arg1 = (uint8_t *)jarg1;
45746   arg2 = (std::size_t)jarg2;
45747   {
45748     try {
45749       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45750     } catch (std::out_of_range& e) {
45751       {
45752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45753       };
45754     } catch (std::exception& e) {
45755       {
45756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45757       };
45758     } catch (Dali::DaliException e) {
45759       {
45760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45761       };
45762     } catch (...) {
45763       {
45764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45765       };
45766     }
45767   }
45768
45769   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45770   return jresult;
45771 }
45772
45773
45774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45775   void * jresult ;
45776   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45777   std::size_t arg2 ;
45778   Dali::ImageDimensions arg3 ;
45779   Dali::FittingMode::Type arg4 ;
45780   Dali::SamplingMode::Type arg5 ;
45781   bool arg6 ;
45782   Dali::ImageDimensions *argp3 ;
45783   Dali::EncodedBufferImage result;
45784
45785   arg1 = (uint8_t *)jarg1;
45786   arg2 = (std::size_t)jarg2;
45787   argp3 = (Dali::ImageDimensions *)jarg3;
45788   if (!argp3) {
45789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45790     return 0;
45791   }
45792   arg3 = *argp3;
45793   arg4 = (Dali::FittingMode::Type)jarg4;
45794   arg5 = (Dali::SamplingMode::Type)jarg5;
45795   arg6 = jarg6 ? true : false;
45796   {
45797     try {
45798       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45799     } catch (std::out_of_range& e) {
45800       {
45801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45802       };
45803     } catch (std::exception& e) {
45804       {
45805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45806       };
45807     } catch (Dali::DaliException e) {
45808       {
45809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45810       };
45811     } catch (...) {
45812       {
45813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45814       };
45815     }
45816   }
45817
45818   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45819   return jresult;
45820 }
45821
45822
45823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45824   void * jresult ;
45825   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45826   std::size_t arg2 ;
45827   Dali::ImageDimensions arg3 ;
45828   Dali::FittingMode::Type arg4 ;
45829   Dali::SamplingMode::Type arg5 ;
45830   Dali::ImageDimensions *argp3 ;
45831   Dali::EncodedBufferImage result;
45832
45833   arg1 = (uint8_t *)jarg1;
45834   arg2 = (std::size_t)jarg2;
45835   argp3 = (Dali::ImageDimensions *)jarg3;
45836   if (!argp3) {
45837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45838     return 0;
45839   }
45840   arg3 = *argp3;
45841   arg4 = (Dali::FittingMode::Type)jarg4;
45842   arg5 = (Dali::SamplingMode::Type)jarg5;
45843   {
45844     try {
45845       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
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_EncodedBufferImage_DownCast(void * jarg1) {
45871   void * jresult ;
45872   Dali::BaseHandle arg1 ;
45873   Dali::BaseHandle *argp1 ;
45874   Dali::EncodedBufferImage result;
45875
45876   argp1 = (Dali::BaseHandle *)jarg1;
45877   if (!argp1) {
45878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45879     return 0;
45880   }
45881   arg1 = *argp1;
45882   {
45883     try {
45884       result = Dali::EncodedBufferImage::DownCast(arg1);
45885     } catch (std::out_of_range& e) {
45886       {
45887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45888       };
45889     } catch (std::exception& e) {
45890       {
45891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45892       };
45893     } catch (Dali::DaliException e) {
45894       {
45895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45896       };
45897     } catch (...) {
45898       {
45899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45900       };
45901     }
45902   }
45903
45904   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45905   return jresult;
45906 }
45907
45908
45909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45910   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45911
45912   arg1 = (Dali::EncodedBufferImage *)jarg1;
45913   {
45914     try {
45915       delete arg1;
45916     } catch (std::out_of_range& e) {
45917       {
45918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45919       };
45920     } catch (std::exception& e) {
45921       {
45922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45923       };
45924     } catch (Dali::DaliException e) {
45925       {
45926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45927       };
45928     } catch (...) {
45929       {
45930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45931       };
45932     }
45933   }
45934
45935 }
45936
45937
45938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45939   void * jresult ;
45940   Dali::EncodedBufferImage *arg1 = 0 ;
45941   Dali::EncodedBufferImage *result = 0 ;
45942
45943   arg1 = (Dali::EncodedBufferImage *)jarg1;
45944   if (!arg1) {
45945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45946     return 0;
45947   }
45948   {
45949     try {
45950       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
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_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45976   void * jresult ;
45977   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45978   Dali::EncodedBufferImage *arg2 = 0 ;
45979   Dali::EncodedBufferImage *result = 0 ;
45980
45981   arg1 = (Dali::EncodedBufferImage *)jarg1;
45982   arg2 = (Dali::EncodedBufferImage *)jarg2;
45983   if (!arg2) {
45984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45985     return 0;
45986   }
45987   {
45988     try {
45989       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45990     } catch (std::out_of_range& e) {
45991       {
45992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45993       };
45994     } catch (std::exception& e) {
45995       {
45996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45997       };
45998     } catch (Dali::DaliException e) {
45999       {
46000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46001       };
46002     } catch (...) {
46003       {
46004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46005       };
46006     }
46007   }
46008
46009   jresult = (void *)result;
46010   return jresult;
46011 }
46012
46013
46014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46015   void * jresult ;
46016   Dali::NativeImage *result = 0 ;
46017
46018   {
46019     try {
46020       result = (Dali::NativeImage *)new Dali::NativeImage();
46021     } catch (std::out_of_range& e) {
46022       {
46023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46024       };
46025     } catch (std::exception& e) {
46026       {
46027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46028       };
46029     } catch (Dali::DaliException e) {
46030       {
46031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46032       };
46033     } catch (...) {
46034       {
46035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46036       };
46037     }
46038   }
46039
46040   jresult = (void *)result;
46041   return jresult;
46042 }
46043
46044
46045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46046   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46047
46048   arg1 = (Dali::NativeImage *)jarg1;
46049   {
46050     try {
46051       delete arg1;
46052     } catch (std::out_of_range& e) {
46053       {
46054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46055       };
46056     } catch (std::exception& e) {
46057       {
46058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46059       };
46060     } catch (Dali::DaliException e) {
46061       {
46062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46063       };
46064     } catch (...) {
46065       {
46066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46067       };
46068     }
46069   }
46070
46071 }
46072
46073
46074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46075   void * jresult ;
46076   Dali::NativeImage *arg1 = 0 ;
46077   Dali::NativeImage *result = 0 ;
46078
46079   arg1 = (Dali::NativeImage *)jarg1;
46080   if (!arg1) {
46081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46082     return 0;
46083   }
46084   {
46085     try {
46086       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
46112   void * jresult ;
46113   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46114   Dali::NativeImage *arg2 = 0 ;
46115   Dali::NativeImage *result = 0 ;
46116
46117   arg1 = (Dali::NativeImage *)jarg1;
46118   arg2 = (Dali::NativeImage *)jarg2;
46119   if (!arg2) {
46120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46121     return 0;
46122   }
46123   {
46124     try {
46125       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46126     } catch (std::out_of_range& e) {
46127       {
46128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46129       };
46130     } catch (std::exception& e) {
46131       {
46132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46133       };
46134     } catch (Dali::DaliException e) {
46135       {
46136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46137       };
46138     } catch (...) {
46139       {
46140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46141       };
46142     }
46143   }
46144
46145   jresult = (void *)result;
46146   return jresult;
46147 }
46148
46149
46150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46151   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46152
46153   arg1 = (Dali::NativeImage *)jarg1;
46154   {
46155     try {
46156       (arg1)->CreateGlTexture();
46157     } catch (std::out_of_range& e) {
46158       {
46159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46160       };
46161     } catch (std::exception& e) {
46162       {
46163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46164       };
46165     } catch (Dali::DaliException e) {
46166       {
46167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46168       };
46169     } catch (...) {
46170       {
46171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46172       };
46173     }
46174   }
46175
46176 }
46177
46178
46179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46180   void * jresult ;
46181   NativeImageInterface *arg1 = 0 ;
46182   Dali::NativeImage result;
46183
46184   arg1 = (NativeImageInterface *)jarg1;
46185   if (!arg1) {
46186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46187     return 0;
46188   }
46189   {
46190     try {
46191       result = Dali::NativeImage::New(*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 void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46217   void * jresult ;
46218   Dali::BaseHandle arg1 ;
46219   Dali::BaseHandle *argp1 ;
46220   Dali::NativeImage result;
46221
46222   argp1 = (Dali::BaseHandle *)jarg1;
46223   if (!argp1) {
46224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46225     return 0;
46226   }
46227   arg1 = *argp1;
46228   {
46229     try {
46230       result = Dali::NativeImage::DownCast(arg1);
46231     } catch (std::out_of_range& e) {
46232       {
46233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46234       };
46235     } catch (std::exception& e) {
46236       {
46237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46238       };
46239     } catch (Dali::DaliException e) {
46240       {
46241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46242       };
46243     } catch (...) {
46244       {
46245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46246       };
46247     }
46248   }
46249
46250   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46251   return jresult;
46252 }
46253
46254
46255 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46256   char * jresult ;
46257   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46258   char *result = 0 ;
46259
46260   arg1 = (Dali::NativeImage *)jarg1;
46261   {
46262     try {
46263       result = (char *)(arg1)->GetCustomFragmentPreFix();
46264     } catch (std::out_of_range& e) {
46265       {
46266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46267       };
46268     } catch (std::exception& e) {
46269       {
46270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46271       };
46272     } catch (Dali::DaliException e) {
46273       {
46274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46275       };
46276     } catch (...) {
46277       {
46278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46279       };
46280     }
46281   }
46282
46283   jresult = SWIG_csharp_string_callback((const char *)result);
46284   return jresult;
46285 }
46286
46287
46288 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46289   char * jresult ;
46290   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46291   char *result = 0 ;
46292
46293   arg1 = (Dali::NativeImage *)jarg1;
46294   {
46295     try {
46296       result = (char *)(arg1)->GetCustomSamplerTypename();
46297     } catch (std::out_of_range& e) {
46298       {
46299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46300       };
46301     } catch (std::exception& e) {
46302       {
46303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46304       };
46305     } catch (Dali::DaliException e) {
46306       {
46307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46308       };
46309     } catch (...) {
46310       {
46311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46312       };
46313     }
46314   }
46315
46316   jresult = SWIG_csharp_string_callback((const char *)result);
46317   return jresult;
46318 }
46319
46320
46321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46322   unsigned int jresult ;
46323   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46324   bool result;
46325
46326   arg1 = (Dali::NativeImageInterface *)jarg1;
46327   {
46328     try {
46329       result = (bool)(arg1)->GlExtensionCreate();
46330     } catch (std::out_of_range& e) {
46331       {
46332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46333       };
46334     } catch (std::exception& e) {
46335       {
46336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46337       };
46338     } catch (Dali::DaliException e) {
46339       {
46340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46341       };
46342     } catch (...) {
46343       {
46344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46345       };
46346     }
46347   }
46348
46349   jresult = result;
46350   return jresult;
46351 }
46352
46353
46354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46355   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46356
46357   arg1 = (Dali::NativeImageInterface *)jarg1;
46358   {
46359     try {
46360       (arg1)->GlExtensionDestroy();
46361     } catch (std::out_of_range& e) {
46362       {
46363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46364       };
46365     } catch (std::exception& e) {
46366       {
46367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46368       };
46369     } catch (Dali::DaliException e) {
46370       {
46371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46372       };
46373     } catch (...) {
46374       {
46375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46376       };
46377     }
46378   }
46379
46380 }
46381
46382
46383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46384   unsigned int jresult ;
46385   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46386   unsigned int result;
46387
46388   arg1 = (Dali::NativeImageInterface *)jarg1;
46389   {
46390     try {
46391       result = (unsigned int)(arg1)->TargetTexture();
46392     } catch (std::out_of_range& e) {
46393       {
46394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46395       };
46396     } catch (std::exception& e) {
46397       {
46398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46399       };
46400     } catch (Dali::DaliException e) {
46401       {
46402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46403       };
46404     } catch (...) {
46405       {
46406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46407       };
46408     }
46409   }
46410
46411   jresult = result;
46412   return jresult;
46413 }
46414
46415
46416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46417   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46418
46419   arg1 = (Dali::NativeImageInterface *)jarg1;
46420   {
46421     try {
46422       (arg1)->PrepareTexture();
46423     } catch (std::out_of_range& e) {
46424       {
46425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46426       };
46427     } catch (std::exception& e) {
46428       {
46429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46430       };
46431     } catch (Dali::DaliException e) {
46432       {
46433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46434       };
46435     } catch (...) {
46436       {
46437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46438       };
46439     }
46440   }
46441
46442 }
46443
46444
46445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46446   unsigned int jresult ;
46447   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46448   unsigned int result;
46449
46450   arg1 = (Dali::NativeImageInterface *)jarg1;
46451   {
46452     try {
46453       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46454     } catch (std::out_of_range& e) {
46455       {
46456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46457       };
46458     } catch (std::exception& e) {
46459       {
46460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46461       };
46462     } catch (Dali::DaliException e) {
46463       {
46464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46465       };
46466     } catch (...) {
46467       {
46468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46469       };
46470     }
46471   }
46472
46473   jresult = result;
46474   return jresult;
46475 }
46476
46477
46478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46479   unsigned int jresult ;
46480   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46481   unsigned int result;
46482
46483   arg1 = (Dali::NativeImageInterface *)jarg1;
46484   {
46485     try {
46486       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46487     } catch (std::out_of_range& e) {
46488       {
46489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46490       };
46491     } catch (std::exception& e) {
46492       {
46493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46494       };
46495     } catch (Dali::DaliException e) {
46496       {
46497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46498       };
46499     } catch (...) {
46500       {
46501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46502       };
46503     }
46504   }
46505
46506   jresult = result;
46507   return jresult;
46508 }
46509
46510
46511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46512   unsigned int jresult ;
46513   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46514   bool result;
46515
46516   arg1 = (Dali::NativeImageInterface *)jarg1;
46517   {
46518     try {
46519       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46520     } catch (std::out_of_range& e) {
46521       {
46522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46523       };
46524     } catch (std::exception& e) {
46525       {
46526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46527       };
46528     } catch (Dali::DaliException e) {
46529       {
46530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46531       };
46532     } catch (...) {
46533       {
46534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46535       };
46536     }
46537   }
46538
46539   jresult = result;
46540   return jresult;
46541 }
46542
46543
46544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46545   void * jresult ;
46546   std::string *arg1 = 0 ;
46547   Dali::ImageDimensions result;
46548
46549   if (!jarg1) {
46550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46551     return 0;
46552   }
46553   std::string arg1_str(jarg1);
46554   arg1 = &arg1_str;
46555   {
46556     try {
46557       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46558     } catch (std::out_of_range& e) {
46559       {
46560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46561       };
46562     } catch (std::exception& e) {
46563       {
46564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46565       };
46566     } catch (Dali::DaliException e) {
46567       {
46568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46569       };
46570     } catch (...) {
46571       {
46572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46573       };
46574     }
46575   }
46576
46577   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46578
46579   //argout typemap for const std::string&
46580
46581   return jresult;
46582 }
46583
46584
46585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46586   void * jresult ;
46587   Dali::ResourceImage *result = 0 ;
46588
46589   {
46590     try {
46591       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46592     } catch (std::out_of_range& e) {
46593       {
46594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46595       };
46596     } catch (std::exception& e) {
46597       {
46598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46599       };
46600     } catch (Dali::DaliException e) {
46601       {
46602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46603       };
46604     } catch (...) {
46605       {
46606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46607       };
46608     }
46609   }
46610
46611   jresult = (void *)result;
46612   return jresult;
46613 }
46614
46615
46616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46617   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46618
46619   arg1 = (Dali::ResourceImage *)jarg1;
46620   {
46621     try {
46622       delete arg1;
46623     } catch (std::out_of_range& e) {
46624       {
46625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46626       };
46627     } catch (std::exception& e) {
46628       {
46629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46630       };
46631     } catch (Dali::DaliException e) {
46632       {
46633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46634       };
46635     } catch (...) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46638       };
46639     }
46640   }
46641
46642 }
46643
46644
46645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46646   void * jresult ;
46647   Dali::ResourceImage *arg1 = 0 ;
46648   Dali::ResourceImage *result = 0 ;
46649
46650   arg1 = (Dali::ResourceImage *)jarg1;
46651   if (!arg1) {
46652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46653     return 0;
46654   }
46655   {
46656     try {
46657       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
46683   void * jresult ;
46684   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46685   Dali::ResourceImage *arg2 = 0 ;
46686   Dali::ResourceImage *result = 0 ;
46687
46688   arg1 = (Dali::ResourceImage *)jarg1;
46689   arg2 = (Dali::ResourceImage *)jarg2;
46690   if (!arg2) {
46691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46692     return 0;
46693   }
46694   {
46695     try {
46696       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46697     } catch (std::out_of_range& e) {
46698       {
46699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46700       };
46701     } catch (std::exception& e) {
46702       {
46703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46704       };
46705     } catch (Dali::DaliException e) {
46706       {
46707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46708       };
46709     } catch (...) {
46710       {
46711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46712       };
46713     }
46714   }
46715
46716   jresult = (void *)result;
46717   return jresult;
46718 }
46719
46720
46721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46722   void * jresult ;
46723   std::string *arg1 = 0 ;
46724   bool arg2 ;
46725   Dali::ResourceImage result;
46726
46727   if (!jarg1) {
46728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46729     return 0;
46730   }
46731   std::string arg1_str(jarg1);
46732   arg1 = &arg1_str;
46733   arg2 = jarg2 ? true : false;
46734   {
46735     try {
46736       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46737     } catch (std::out_of_range& e) {
46738       {
46739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46740       };
46741     } catch (std::exception& e) {
46742       {
46743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46744       };
46745     } catch (Dali::DaliException e) {
46746       {
46747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46748       };
46749     } catch (...) {
46750       {
46751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46752       };
46753     }
46754   }
46755
46756   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46757
46758   //argout typemap for const std::string&
46759
46760   return jresult;
46761 }
46762
46763
46764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46765   void * jresult ;
46766   std::string *arg1 = 0 ;
46767   Dali::ResourceImage result;
46768
46769   if (!jarg1) {
46770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46771     return 0;
46772   }
46773   std::string arg1_str(jarg1);
46774   arg1 = &arg1_str;
46775   {
46776     try {
46777       result = Dali::ResourceImage::New((std::string const &)*arg1);
46778     } catch (std::out_of_range& e) {
46779       {
46780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46781       };
46782     } catch (std::exception& e) {
46783       {
46784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46785       };
46786     } catch (Dali::DaliException e) {
46787       {
46788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46789       };
46790     } catch (...) {
46791       {
46792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46793       };
46794     }
46795   }
46796
46797   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46798
46799   //argout typemap for const std::string&
46800
46801   return jresult;
46802 }
46803
46804
46805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46806   void * jresult ;
46807   std::string *arg1 = 0 ;
46808   Dali::ImageDimensions arg2 ;
46809   Dali::FittingMode::Type arg3 ;
46810   Dali::SamplingMode::Type arg4 ;
46811   bool arg5 ;
46812   Dali::ImageDimensions *argp2 ;
46813   Dali::ResourceImage result;
46814
46815   if (!jarg1) {
46816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46817     return 0;
46818   }
46819   std::string arg1_str(jarg1);
46820   arg1 = &arg1_str;
46821   argp2 = (Dali::ImageDimensions *)jarg2;
46822   if (!argp2) {
46823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46824     return 0;
46825   }
46826   arg2 = *argp2;
46827   arg3 = (Dali::FittingMode::Type)jarg3;
46828   arg4 = (Dali::SamplingMode::Type)jarg4;
46829   arg5 = jarg5 ? true : false;
46830   {
46831     try {
46832       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46833     } catch (std::out_of_range& e) {
46834       {
46835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46836       };
46837     } catch (std::exception& e) {
46838       {
46839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46840       };
46841     } catch (Dali::DaliException e) {
46842       {
46843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46844       };
46845     } catch (...) {
46846       {
46847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46848       };
46849     }
46850   }
46851
46852   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46853
46854   //argout typemap for const std::string&
46855
46856   return jresult;
46857 }
46858
46859
46860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46861   void * jresult ;
46862   std::string *arg1 = 0 ;
46863   Dali::ImageDimensions arg2 ;
46864   Dali::FittingMode::Type arg3 ;
46865   Dali::SamplingMode::Type arg4 ;
46866   Dali::ImageDimensions *argp2 ;
46867   Dali::ResourceImage result;
46868
46869   if (!jarg1) {
46870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46871     return 0;
46872   }
46873   std::string arg1_str(jarg1);
46874   arg1 = &arg1_str;
46875   argp2 = (Dali::ImageDimensions *)jarg2;
46876   if (!argp2) {
46877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46878     return 0;
46879   }
46880   arg2 = *argp2;
46881   arg3 = (Dali::FittingMode::Type)jarg3;
46882   arg4 = (Dali::SamplingMode::Type)jarg4;
46883   {
46884     try {
46885       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46886     } catch (std::out_of_range& e) {
46887       {
46888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46889       };
46890     } catch (std::exception& e) {
46891       {
46892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46893       };
46894     } catch (Dali::DaliException e) {
46895       {
46896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46897       };
46898     } catch (...) {
46899       {
46900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46901       };
46902     }
46903   }
46904
46905   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46906
46907   //argout typemap for const std::string&
46908
46909   return jresult;
46910 }
46911
46912
46913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46914   void * jresult ;
46915   std::string *arg1 = 0 ;
46916   Dali::ImageDimensions arg2 ;
46917   Dali::FittingMode::Type arg3 ;
46918   Dali::ImageDimensions *argp2 ;
46919   Dali::ResourceImage result;
46920
46921   if (!jarg1) {
46922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46923     return 0;
46924   }
46925   std::string arg1_str(jarg1);
46926   arg1 = &arg1_str;
46927   argp2 = (Dali::ImageDimensions *)jarg2;
46928   if (!argp2) {
46929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46930     return 0;
46931   }
46932   arg2 = *argp2;
46933   arg3 = (Dali::FittingMode::Type)jarg3;
46934   {
46935     try {
46936       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46937     } catch (std::out_of_range& e) {
46938       {
46939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46940       };
46941     } catch (std::exception& e) {
46942       {
46943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46944       };
46945     } catch (Dali::DaliException e) {
46946       {
46947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46948       };
46949     } catch (...) {
46950       {
46951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46952       };
46953     }
46954   }
46955
46956   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46957
46958   //argout typemap for const std::string&
46959
46960   return jresult;
46961 }
46962
46963
46964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46965   void * jresult ;
46966   std::string *arg1 = 0 ;
46967   Dali::ImageDimensions arg2 ;
46968   Dali::ImageDimensions *argp2 ;
46969   Dali::ResourceImage result;
46970
46971   if (!jarg1) {
46972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46973     return 0;
46974   }
46975   std::string arg1_str(jarg1);
46976   arg1 = &arg1_str;
46977   argp2 = (Dali::ImageDimensions *)jarg2;
46978   if (!argp2) {
46979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46980     return 0;
46981   }
46982   arg2 = *argp2;
46983   {
46984     try {
46985       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46986     } catch (std::out_of_range& e) {
46987       {
46988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46989       };
46990     } catch (std::exception& e) {
46991       {
46992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46993       };
46994     } catch (Dali::DaliException e) {
46995       {
46996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46997       };
46998     } catch (...) {
46999       {
47000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47001       };
47002     }
47003   }
47004
47005   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47006
47007   //argout typemap for const std::string&
47008
47009   return jresult;
47010 }
47011
47012
47013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47014   void * jresult ;
47015   Dali::BaseHandle arg1 ;
47016   Dali::BaseHandle *argp1 ;
47017   Dali::ResourceImage result;
47018
47019   argp1 = (Dali::BaseHandle *)jarg1;
47020   if (!argp1) {
47021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47022     return 0;
47023   }
47024   arg1 = *argp1;
47025   {
47026     try {
47027       result = Dali::ResourceImage::DownCast(arg1);
47028     } catch (std::out_of_range& e) {
47029       {
47030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47031       };
47032     } catch (std::exception& e) {
47033       {
47034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47035       };
47036     } catch (Dali::DaliException e) {
47037       {
47038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47039       };
47040     } catch (...) {
47041       {
47042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47043       };
47044     }
47045   }
47046
47047   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47048   return jresult;
47049 }
47050
47051
47052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47053   int jresult ;
47054   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47055   Dali::LoadingState result;
47056
47057   arg1 = (Dali::ResourceImage *)jarg1;
47058   {
47059     try {
47060       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47061     } catch (std::out_of_range& e) {
47062       {
47063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47064       };
47065     } catch (std::exception& e) {
47066       {
47067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47068       };
47069     } catch (Dali::DaliException e) {
47070       {
47071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47072       };
47073     } catch (...) {
47074       {
47075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47076       };
47077     }
47078   }
47079
47080   jresult = (int)result;
47081   return jresult;
47082 }
47083
47084
47085 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47086   char * jresult ;
47087   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47088   std::string result;
47089
47090   arg1 = (Dali::ResourceImage *)jarg1;
47091   {
47092     try {
47093       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47094     } catch (std::out_of_range& e) {
47095       {
47096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47097       };
47098     } catch (std::exception& e) {
47099       {
47100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47101       };
47102     } catch (Dali::DaliException e) {
47103       {
47104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47105       };
47106     } catch (...) {
47107       {
47108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47109       };
47110     }
47111   }
47112
47113   jresult = SWIG_csharp_string_callback((&result)->c_str());
47114   return jresult;
47115 }
47116
47117
47118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47119   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47120
47121   arg1 = (Dali::ResourceImage *)jarg1;
47122   {
47123     try {
47124       (arg1)->Reload();
47125     } catch (std::out_of_range& e) {
47126       {
47127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47128       };
47129     } catch (std::exception& e) {
47130       {
47131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47132       };
47133     } catch (Dali::DaliException e) {
47134       {
47135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47136       };
47137     } catch (...) {
47138       {
47139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47140       };
47141     }
47142   }
47143
47144 }
47145
47146
47147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47148   void * jresult ;
47149   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47150   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47151
47152   arg1 = (Dali::ResourceImage *)jarg1;
47153   {
47154     try {
47155       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47156     } catch (std::out_of_range& e) {
47157       {
47158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47159       };
47160     } catch (std::exception& e) {
47161       {
47162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47163       };
47164     } catch (Dali::DaliException e) {
47165       {
47166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47167       };
47168     } catch (...) {
47169       {
47170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47171       };
47172     }
47173   }
47174
47175   jresult = (void *)result;
47176   return jresult;
47177 }
47178
47179
47180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47181   void * jresult ;
47182   Dali::FrameBufferImage *result = 0 ;
47183
47184   {
47185     try {
47186       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
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 = (void *)result;
47207   return jresult;
47208 }
47209
47210
47211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47212   void * jresult ;
47213   unsigned int arg1 ;
47214   unsigned int arg2 ;
47215   Dali::Pixel::Format arg3 ;
47216   Dali::RenderBuffer::Format arg4 ;
47217   Dali::FrameBufferImage result;
47218
47219   arg1 = (unsigned int)jarg1;
47220   arg2 = (unsigned int)jarg2;
47221   arg3 = (Dali::Pixel::Format)jarg3;
47222   arg4 = (Dali::RenderBuffer::Format)jarg4;
47223   {
47224     try {
47225       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47226     } catch (std::out_of_range& e) {
47227       {
47228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47229       };
47230     } catch (std::exception& e) {
47231       {
47232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47233       };
47234     } catch (Dali::DaliException e) {
47235       {
47236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47237       };
47238     } catch (...) {
47239       {
47240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47241       };
47242     }
47243   }
47244
47245   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47246   return jresult;
47247 }
47248
47249
47250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47251   void * jresult ;
47252   unsigned int arg1 ;
47253   unsigned int arg2 ;
47254   Dali::Pixel::Format arg3 ;
47255   Dali::FrameBufferImage result;
47256
47257   arg1 = (unsigned int)jarg1;
47258   arg2 = (unsigned int)jarg2;
47259   arg3 = (Dali::Pixel::Format)jarg3;
47260   {
47261     try {
47262       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47263     } catch (std::out_of_range& e) {
47264       {
47265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47266       };
47267     } catch (std::exception& e) {
47268       {
47269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47270       };
47271     } catch (Dali::DaliException e) {
47272       {
47273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47274       };
47275     } catch (...) {
47276       {
47277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47278       };
47279     }
47280   }
47281
47282   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47283   return jresult;
47284 }
47285
47286
47287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47288   void * jresult ;
47289   unsigned int arg1 ;
47290   unsigned int arg2 ;
47291   Dali::FrameBufferImage result;
47292
47293   arg1 = (unsigned int)jarg1;
47294   arg2 = (unsigned int)jarg2;
47295   {
47296     try {
47297       result = Dali::FrameBufferImage::New(arg1,arg2);
47298     } catch (std::out_of_range& e) {
47299       {
47300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47301       };
47302     } catch (std::exception& e) {
47303       {
47304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47305       };
47306     } catch (Dali::DaliException e) {
47307       {
47308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47309       };
47310     } catch (...) {
47311       {
47312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47313       };
47314     }
47315   }
47316
47317   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47318   return jresult;
47319 }
47320
47321
47322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47323   void * jresult ;
47324   unsigned int arg1 ;
47325   Dali::FrameBufferImage result;
47326
47327   arg1 = (unsigned int)jarg1;
47328   {
47329     try {
47330       result = Dali::FrameBufferImage::New(arg1);
47331     } catch (std::out_of_range& e) {
47332       {
47333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47334       };
47335     } catch (std::exception& e) {
47336       {
47337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47338       };
47339     } catch (Dali::DaliException e) {
47340       {
47341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47342       };
47343     } catch (...) {
47344       {
47345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47346       };
47347     }
47348   }
47349
47350   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47351   return jresult;
47352 }
47353
47354
47355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47356   void * jresult ;
47357   Dali::FrameBufferImage result;
47358
47359   {
47360     try {
47361       result = Dali::FrameBufferImage::New();
47362     } catch (std::out_of_range& e) {
47363       {
47364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47365       };
47366     } catch (std::exception& e) {
47367       {
47368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47369       };
47370     } catch (Dali::DaliException e) {
47371       {
47372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47373       };
47374     } catch (...) {
47375       {
47376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47377       };
47378     }
47379   }
47380
47381   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47382   return jresult;
47383 }
47384
47385
47386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47387   void * jresult ;
47388   Dali::NativeImageInterface *arg1 = 0 ;
47389   Dali::FrameBufferImage result;
47390
47391   arg1 = (Dali::NativeImageInterface *)jarg1;
47392   if (!arg1) {
47393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47394     return 0;
47395   }
47396   {
47397     try {
47398       result = Dali::FrameBufferImage::New(*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_FrameBufferImage_DownCast(void * jarg1) {
47424   void * jresult ;
47425   Dali::BaseHandle arg1 ;
47426   Dali::BaseHandle *argp1 ;
47427   Dali::FrameBufferImage result;
47428
47429   argp1 = (Dali::BaseHandle *)jarg1;
47430   if (!argp1) {
47431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47432     return 0;
47433   }
47434   arg1 = *argp1;
47435   {
47436     try {
47437       result = Dali::FrameBufferImage::DownCast(arg1);
47438     } catch (std::out_of_range& e) {
47439       {
47440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47441       };
47442     } catch (std::exception& e) {
47443       {
47444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47445       };
47446     } catch (Dali::DaliException e) {
47447       {
47448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47449       };
47450     } catch (...) {
47451       {
47452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47453       };
47454     }
47455   }
47456
47457   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47458   return jresult;
47459 }
47460
47461
47462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47463   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47464
47465   arg1 = (Dali::FrameBufferImage *)jarg1;
47466   {
47467     try {
47468       delete arg1;
47469     } catch (std::out_of_range& e) {
47470       {
47471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47472       };
47473     } catch (std::exception& e) {
47474       {
47475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47476       };
47477     } catch (Dali::DaliException e) {
47478       {
47479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47480       };
47481     } catch (...) {
47482       {
47483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47484       };
47485     }
47486   }
47487
47488 }
47489
47490
47491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47492   void * jresult ;
47493   Dali::FrameBufferImage *arg1 = 0 ;
47494   Dali::FrameBufferImage *result = 0 ;
47495
47496   arg1 = (Dali::FrameBufferImage *)jarg1;
47497   if (!arg1) {
47498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47499     return 0;
47500   }
47501   {
47502     try {
47503       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
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_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47529   void * jresult ;
47530   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47531   Dali::FrameBufferImage *arg2 = 0 ;
47532   Dali::FrameBufferImage *result = 0 ;
47533
47534   arg1 = (Dali::FrameBufferImage *)jarg1;
47535   arg2 = (Dali::FrameBufferImage *)jarg2;
47536   if (!arg2) {
47537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47538     return 0;
47539   }
47540   {
47541     try {
47542       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47543     } catch (std::out_of_range& e) {
47544       {
47545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47546       };
47547     } catch (std::exception& e) {
47548       {
47549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47550       };
47551     } catch (Dali::DaliException e) {
47552       {
47553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47554       };
47555     } catch (...) {
47556       {
47557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47558       };
47559     }
47560   }
47561
47562   jresult = (void *)result;
47563   return jresult;
47564 }
47565
47566
47567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47568   void * jresult ;
47569   Dali::NinePatchImage *result = 0 ;
47570
47571   {
47572     try {
47573       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47574     } catch (std::out_of_range& e) {
47575       {
47576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47577       };
47578     } catch (std::exception& e) {
47579       {
47580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47581       };
47582     } catch (Dali::DaliException e) {
47583       {
47584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47585       };
47586     } catch (...) {
47587       {
47588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47589       };
47590     }
47591   }
47592
47593   jresult = (void *)result;
47594   return jresult;
47595 }
47596
47597
47598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47599   void * jresult ;
47600   std::string *arg1 = 0 ;
47601   Dali::NinePatchImage result;
47602
47603   if (!jarg1) {
47604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47605     return 0;
47606   }
47607   std::string arg1_str(jarg1);
47608   arg1 = &arg1_str;
47609   {
47610     try {
47611       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47612     } catch (std::out_of_range& e) {
47613       {
47614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47615       };
47616     } catch (std::exception& e) {
47617       {
47618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47619       };
47620     } catch (Dali::DaliException e) {
47621       {
47622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47623       };
47624     } catch (...) {
47625       {
47626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47627       };
47628     }
47629   }
47630
47631   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47632
47633   //argout typemap for const std::string&
47634
47635   return jresult;
47636 }
47637
47638
47639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47640   void * jresult ;
47641   Dali::BaseHandle arg1 ;
47642   Dali::BaseHandle *argp1 ;
47643   Dali::NinePatchImage result;
47644
47645   argp1 = (Dali::BaseHandle *)jarg1;
47646   if (!argp1) {
47647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47648     return 0;
47649   }
47650   arg1 = *argp1;
47651   {
47652     try {
47653       result = Dali::NinePatchImage::DownCast(arg1);
47654     } catch (std::out_of_range& e) {
47655       {
47656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47657       };
47658     } catch (std::exception& e) {
47659       {
47660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47661       };
47662     } catch (Dali::DaliException e) {
47663       {
47664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47665       };
47666     } catch (...) {
47667       {
47668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47669       };
47670     }
47671   }
47672
47673   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47674   return jresult;
47675 }
47676
47677
47678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47679   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47680
47681   arg1 = (Dali::NinePatchImage *)jarg1;
47682   {
47683     try {
47684       delete arg1;
47685     } catch (std::out_of_range& e) {
47686       {
47687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47688       };
47689     } catch (std::exception& e) {
47690       {
47691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47692       };
47693     } catch (Dali::DaliException e) {
47694       {
47695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47696       };
47697     } catch (...) {
47698       {
47699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47700       };
47701     }
47702   }
47703
47704 }
47705
47706
47707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47708   void * jresult ;
47709   Dali::NinePatchImage *arg1 = 0 ;
47710   Dali::NinePatchImage *result = 0 ;
47711
47712   arg1 = (Dali::NinePatchImage *)jarg1;
47713   if (!arg1) {
47714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47715     return 0;
47716   }
47717   {
47718     try {
47719       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
47745   void * jresult ;
47746   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47747   Dali::NinePatchImage *arg2 = 0 ;
47748   Dali::NinePatchImage *result = 0 ;
47749
47750   arg1 = (Dali::NinePatchImage *)jarg1;
47751   arg2 = (Dali::NinePatchImage *)jarg2;
47752   if (!arg2) {
47753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47754     return 0;
47755   }
47756   {
47757     try {
47758       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47759     } catch (std::out_of_range& e) {
47760       {
47761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47762       };
47763     } catch (std::exception& e) {
47764       {
47765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47766       };
47767     } catch (Dali::DaliException e) {
47768       {
47769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47770       };
47771     } catch (...) {
47772       {
47773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47774       };
47775     }
47776   }
47777
47778   jresult = (void *)result;
47779   return jresult;
47780 }
47781
47782
47783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47784   void * jresult ;
47785   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47786   Dali::Vector4 result;
47787
47788   arg1 = (Dali::NinePatchImage *)jarg1;
47789   {
47790     try {
47791       result = (arg1)->GetStretchBorders();
47792     } catch (std::out_of_range& e) {
47793       {
47794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47795       };
47796     } catch (std::exception& e) {
47797       {
47798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47799       };
47800     } catch (Dali::DaliException e) {
47801       {
47802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47803       };
47804     } catch (...) {
47805       {
47806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47807       };
47808     }
47809   }
47810
47811   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47812   return jresult;
47813 }
47814
47815
47816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47817   void * jresult ;
47818   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47819   Dali::NinePatchImage::StretchRanges *result = 0 ;
47820
47821   arg1 = (Dali::NinePatchImage *)jarg1;
47822   {
47823     try {
47824       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47825     } catch (std::out_of_range& e) {
47826       {
47827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47828       };
47829     } catch (std::exception& e) {
47830       {
47831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47832       };
47833     } catch (Dali::DaliException e) {
47834       {
47835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47836       };
47837     } catch (...) {
47838       {
47839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47840       };
47841     }
47842   }
47843
47844   jresult = (void *)result;
47845   return jresult;
47846 }
47847
47848
47849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47850   void * jresult ;
47851   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47852   Dali::NinePatchImage::StretchRanges *result = 0 ;
47853
47854   arg1 = (Dali::NinePatchImage *)jarg1;
47855   {
47856     try {
47857       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47858     } catch (std::out_of_range& e) {
47859       {
47860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47861       };
47862     } catch (std::exception& e) {
47863       {
47864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47865       };
47866     } catch (Dali::DaliException e) {
47867       {
47868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47869       };
47870     } catch (...) {
47871       {
47872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47873       };
47874     }
47875   }
47876
47877   jresult = (void *)result;
47878   return jresult;
47879 }
47880
47881
47882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47883   void * jresult ;
47884   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47885   Dali::Rect< int > result;
47886
47887   arg1 = (Dali::NinePatchImage *)jarg1;
47888   {
47889     try {
47890       result = (arg1)->GetChildRectangle();
47891     } catch (std::out_of_range& e) {
47892       {
47893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47894       };
47895     } catch (std::exception& e) {
47896       {
47897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47898       };
47899     } catch (Dali::DaliException e) {
47900       {
47901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47902       };
47903     } catch (...) {
47904       {
47905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47906       };
47907     }
47908   }
47909
47910   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47911   return jresult;
47912 }
47913
47914
47915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47916   void * jresult ;
47917   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47918   Dali::BufferImage result;
47919
47920   arg1 = (Dali::NinePatchImage *)jarg1;
47921   {
47922     try {
47923       result = (arg1)->CreateCroppedBufferImage();
47924     } catch (std::out_of_range& e) {
47925       {
47926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47927       };
47928     } catch (std::exception& e) {
47929       {
47930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47931       };
47932     } catch (Dali::DaliException e) {
47933       {
47934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47935       };
47936     } catch (...) {
47937       {
47938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47939       };
47940     }
47941   }
47942
47943   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47944   return jresult;
47945 }
47946
47947
47948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47949   unsigned int jresult ;
47950   std::string *arg1 = 0 ;
47951   bool result;
47952
47953   if (!jarg1) {
47954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47955     return 0;
47956   }
47957   std::string arg1_str(jarg1);
47958   arg1 = &arg1_str;
47959   {
47960     try {
47961       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47962     } catch (std::out_of_range& e) {
47963       {
47964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47965       };
47966     } catch (std::exception& e) {
47967       {
47968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47969       };
47970     } catch (Dali::DaliException e) {
47971       {
47972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47973       };
47974     } catch (...) {
47975       {
47976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47977       };
47978     }
47979   }
47980
47981   jresult = result;
47982
47983   //argout typemap for const std::string&
47984
47985   return jresult;
47986 }
47987
47988
47989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47990   int jresult ;
47991   int result;
47992
47993   result = (int)Dali::CameraActor::Property::TYPE;
47994   jresult = (int)result;
47995   return jresult;
47996 }
47997
47998
47999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48000   int jresult ;
48001   int result;
48002
48003   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48004   jresult = (int)result;
48005   return jresult;
48006 }
48007
48008
48009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48010   int jresult ;
48011   int result;
48012
48013   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48014   jresult = (int)result;
48015   return jresult;
48016 }
48017
48018
48019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48020   int jresult ;
48021   int result;
48022
48023   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48024   jresult = (int)result;
48025   return jresult;
48026 }
48027
48028
48029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48030   int jresult ;
48031   int result;
48032
48033   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48034   jresult = (int)result;
48035   return jresult;
48036 }
48037
48038
48039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48040   int jresult ;
48041   int result;
48042
48043   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48044   jresult = (int)result;
48045   return jresult;
48046 }
48047
48048
48049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48050   int jresult ;
48051   int result;
48052
48053   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48054   jresult = (int)result;
48055   return jresult;
48056 }
48057
48058
48059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48060   int jresult ;
48061   int result;
48062
48063   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48064   jresult = (int)result;
48065   return jresult;
48066 }
48067
48068
48069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48070   int jresult ;
48071   int result;
48072
48073   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48074   jresult = (int)result;
48075   return jresult;
48076 }
48077
48078
48079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48080   int jresult ;
48081   int result;
48082
48083   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48084   jresult = (int)result;
48085   return jresult;
48086 }
48087
48088
48089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48090   int jresult ;
48091   int result;
48092
48093   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48094   jresult = (int)result;
48095   return jresult;
48096 }
48097
48098
48099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48100   int jresult ;
48101   int result;
48102
48103   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48104   jresult = (int)result;
48105   return jresult;
48106 }
48107
48108
48109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48110   int jresult ;
48111   int result;
48112
48113   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48114   jresult = (int)result;
48115   return jresult;
48116 }
48117
48118
48119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48120   int jresult ;
48121   int result;
48122
48123   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48124   jresult = (int)result;
48125   return jresult;
48126 }
48127
48128
48129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48130   void * jresult ;
48131   Dali::CameraActor::Property *result = 0 ;
48132
48133   {
48134     try {
48135       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48136     } catch (std::out_of_range& e) {
48137       {
48138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48139       };
48140     } catch (std::exception& e) {
48141       {
48142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48143       };
48144     } catch (Dali::DaliException e) {
48145       {
48146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48147       };
48148     } catch (...) {
48149       {
48150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48151       };
48152     }
48153   }
48154
48155   jresult = (void *)result;
48156   return jresult;
48157 }
48158
48159
48160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48161   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48162
48163   arg1 = (Dali::CameraActor::Property *)jarg1;
48164   {
48165     try {
48166       delete arg1;
48167     } catch (std::out_of_range& e) {
48168       {
48169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48170       };
48171     } catch (std::exception& e) {
48172       {
48173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48174       };
48175     } catch (Dali::DaliException e) {
48176       {
48177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48178       };
48179     } catch (...) {
48180       {
48181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48182       };
48183     }
48184   }
48185
48186 }
48187
48188
48189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48190   void * jresult ;
48191   Dali::CameraActor *result = 0 ;
48192
48193   {
48194     try {
48195       result = (Dali::CameraActor *)new Dali::CameraActor();
48196     } catch (std::out_of_range& e) {
48197       {
48198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48199       };
48200     } catch (std::exception& e) {
48201       {
48202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48203       };
48204     } catch (Dali::DaliException e) {
48205       {
48206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48207       };
48208     } catch (...) {
48209       {
48210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48211       };
48212     }
48213   }
48214
48215   jresult = (void *)result;
48216   return jresult;
48217 }
48218
48219
48220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48221   void * jresult ;
48222   Dali::CameraActor result;
48223
48224   {
48225     try {
48226       result = Dali::CameraActor::New();
48227     } catch (std::out_of_range& e) {
48228       {
48229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48230       };
48231     } catch (std::exception& e) {
48232       {
48233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48234       };
48235     } catch (Dali::DaliException e) {
48236       {
48237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48238       };
48239     } catch (...) {
48240       {
48241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48242       };
48243     }
48244   }
48245
48246   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48247   return jresult;
48248 }
48249
48250
48251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48252   void * jresult ;
48253   Dali::Size *arg1 = 0 ;
48254   Dali::CameraActor result;
48255
48256   arg1 = (Dali::Size *)jarg1;
48257   if (!arg1) {
48258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48259     return 0;
48260   }
48261   {
48262     try {
48263       result = Dali::CameraActor::New((Dali::Vector2 const &)*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_CameraActor_DownCast(void * jarg1) {
48289   void * jresult ;
48290   Dali::BaseHandle arg1 ;
48291   Dali::BaseHandle *argp1 ;
48292   Dali::CameraActor result;
48293
48294   argp1 = (Dali::BaseHandle *)jarg1;
48295   if (!argp1) {
48296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48297     return 0;
48298   }
48299   arg1 = *argp1;
48300   {
48301     try {
48302       result = Dali::CameraActor::DownCast(arg1);
48303     } catch (std::out_of_range& e) {
48304       {
48305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48306       };
48307     } catch (std::exception& e) {
48308       {
48309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48310       };
48311     } catch (Dali::DaliException e) {
48312       {
48313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48314       };
48315     } catch (...) {
48316       {
48317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48318       };
48319     }
48320   }
48321
48322   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48323   return jresult;
48324 }
48325
48326
48327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48328   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48329
48330   arg1 = (Dali::CameraActor *)jarg1;
48331   {
48332     try {
48333       delete arg1;
48334     } catch (std::out_of_range& e) {
48335       {
48336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48337       };
48338     } catch (std::exception& e) {
48339       {
48340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48341       };
48342     } catch (Dali::DaliException e) {
48343       {
48344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48345       };
48346     } catch (...) {
48347       {
48348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48349       };
48350     }
48351   }
48352
48353 }
48354
48355
48356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48357   void * jresult ;
48358   Dali::CameraActor *arg1 = 0 ;
48359   Dali::CameraActor *result = 0 ;
48360
48361   arg1 = (Dali::CameraActor *)jarg1;
48362   if (!arg1) {
48363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48364     return 0;
48365   }
48366   {
48367     try {
48368       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
48394   void * jresult ;
48395   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48396   Dali::CameraActor *arg2 = 0 ;
48397   Dali::CameraActor *result = 0 ;
48398
48399   arg1 = (Dali::CameraActor *)jarg1;
48400   arg2 = (Dali::CameraActor *)jarg2;
48401   if (!arg2) {
48402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48403     return 0;
48404   }
48405   {
48406     try {
48407       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48408     } catch (std::out_of_range& e) {
48409       {
48410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48411       };
48412     } catch (std::exception& e) {
48413       {
48414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48415       };
48416     } catch (Dali::DaliException e) {
48417       {
48418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48419       };
48420     } catch (...) {
48421       {
48422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48423       };
48424     }
48425   }
48426
48427   jresult = (void *)result;
48428   return jresult;
48429 }
48430
48431
48432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48433   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48434   Dali::Camera::Type arg2 ;
48435
48436   arg1 = (Dali::CameraActor *)jarg1;
48437   arg2 = (Dali::Camera::Type)jarg2;
48438   {
48439     try {
48440       (arg1)->SetType(arg2);
48441     } catch (std::out_of_range& e) {
48442       {
48443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48444       };
48445     } catch (std::exception& e) {
48446       {
48447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48448       };
48449     } catch (Dali::DaliException e) {
48450       {
48451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48452       };
48453     } catch (...) {
48454       {
48455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48456       };
48457     }
48458   }
48459
48460 }
48461
48462
48463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48464   int jresult ;
48465   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48466   Dali::Camera::Type result;
48467
48468   arg1 = (Dali::CameraActor *)jarg1;
48469   {
48470     try {
48471       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48472     } catch (std::out_of_range& e) {
48473       {
48474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48475       };
48476     } catch (std::exception& e) {
48477       {
48478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48479       };
48480     } catch (Dali::DaliException e) {
48481       {
48482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48483       };
48484     } catch (...) {
48485       {
48486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48487       };
48488     }
48489   }
48490
48491   jresult = (int)result;
48492   return jresult;
48493 }
48494
48495
48496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48497   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48498   Dali::Camera::ProjectionMode arg2 ;
48499
48500   arg1 = (Dali::CameraActor *)jarg1;
48501   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48502   {
48503     try {
48504       (arg1)->SetProjectionMode(arg2);
48505     } catch (std::out_of_range& e) {
48506       {
48507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48508       };
48509     } catch (std::exception& e) {
48510       {
48511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48512       };
48513     } catch (Dali::DaliException e) {
48514       {
48515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48516       };
48517     } catch (...) {
48518       {
48519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48520       };
48521     }
48522   }
48523
48524 }
48525
48526
48527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48528   int jresult ;
48529   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48530   Dali::Camera::ProjectionMode result;
48531
48532   arg1 = (Dali::CameraActor *)jarg1;
48533   {
48534     try {
48535       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48536     } catch (std::out_of_range& e) {
48537       {
48538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48539       };
48540     } catch (std::exception& e) {
48541       {
48542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48543       };
48544     } catch (Dali::DaliException e) {
48545       {
48546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48547       };
48548     } catch (...) {
48549       {
48550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48551       };
48552     }
48553   }
48554
48555   jresult = (int)result;
48556   return jresult;
48557 }
48558
48559
48560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48561   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48562   float arg2 ;
48563
48564   arg1 = (Dali::CameraActor *)jarg1;
48565   arg2 = (float)jarg2;
48566   {
48567     try {
48568       (arg1)->SetFieldOfView(arg2);
48569     } catch (std::out_of_range& e) {
48570       {
48571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48572       };
48573     } catch (std::exception& e) {
48574       {
48575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48576       };
48577     } catch (Dali::DaliException e) {
48578       {
48579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48580       };
48581     } catch (...) {
48582       {
48583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48584       };
48585     }
48586   }
48587
48588 }
48589
48590
48591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48592   float jresult ;
48593   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48594   float result;
48595
48596   arg1 = (Dali::CameraActor *)jarg1;
48597   {
48598     try {
48599       result = (float)(arg1)->GetFieldOfView();
48600     } catch (std::out_of_range& e) {
48601       {
48602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48603       };
48604     } catch (std::exception& e) {
48605       {
48606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48607       };
48608     } catch (Dali::DaliException e) {
48609       {
48610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48611       };
48612     } catch (...) {
48613       {
48614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48615       };
48616     }
48617   }
48618
48619   jresult = result;
48620   return jresult;
48621 }
48622
48623
48624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48625   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48626   float arg2 ;
48627
48628   arg1 = (Dali::CameraActor *)jarg1;
48629   arg2 = (float)jarg2;
48630   {
48631     try {
48632       (arg1)->SetAspectRatio(arg2);
48633     } catch (std::out_of_range& e) {
48634       {
48635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48636       };
48637     } catch (std::exception& e) {
48638       {
48639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48640       };
48641     } catch (Dali::DaliException e) {
48642       {
48643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48644       };
48645     } catch (...) {
48646       {
48647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48648       };
48649     }
48650   }
48651
48652 }
48653
48654
48655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48656   float jresult ;
48657   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48658   float result;
48659
48660   arg1 = (Dali::CameraActor *)jarg1;
48661   {
48662     try {
48663       result = (float)(arg1)->GetAspectRatio();
48664     } catch (std::out_of_range& e) {
48665       {
48666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48667       };
48668     } catch (std::exception& e) {
48669       {
48670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48671       };
48672     } catch (Dali::DaliException e) {
48673       {
48674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48675       };
48676     } catch (...) {
48677       {
48678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48679       };
48680     }
48681   }
48682
48683   jresult = result;
48684   return jresult;
48685 }
48686
48687
48688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48689   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48690   float arg2 ;
48691
48692   arg1 = (Dali::CameraActor *)jarg1;
48693   arg2 = (float)jarg2;
48694   {
48695     try {
48696       (arg1)->SetNearClippingPlane(arg2);
48697     } catch (std::out_of_range& e) {
48698       {
48699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48700       };
48701     } catch (std::exception& e) {
48702       {
48703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48704       };
48705     } catch (Dali::DaliException e) {
48706       {
48707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48708       };
48709     } catch (...) {
48710       {
48711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48712       };
48713     }
48714   }
48715
48716 }
48717
48718
48719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48720   float jresult ;
48721   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48722   float result;
48723
48724   arg1 = (Dali::CameraActor *)jarg1;
48725   {
48726     try {
48727       result = (float)(arg1)->GetNearClippingPlane();
48728     } catch (std::out_of_range& e) {
48729       {
48730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48731       };
48732     } catch (std::exception& e) {
48733       {
48734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48735       };
48736     } catch (Dali::DaliException e) {
48737       {
48738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48739       };
48740     } catch (...) {
48741       {
48742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48743       };
48744     }
48745   }
48746
48747   jresult = result;
48748   return jresult;
48749 }
48750
48751
48752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48753   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48754   float arg2 ;
48755
48756   arg1 = (Dali::CameraActor *)jarg1;
48757   arg2 = (float)jarg2;
48758   {
48759     try {
48760       (arg1)->SetFarClippingPlane(arg2);
48761     } catch (std::out_of_range& e) {
48762       {
48763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48764       };
48765     } catch (std::exception& e) {
48766       {
48767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48768       };
48769     } catch (Dali::DaliException e) {
48770       {
48771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48772       };
48773     } catch (...) {
48774       {
48775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48776       };
48777     }
48778   }
48779
48780 }
48781
48782
48783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48784   float jresult ;
48785   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48786   float result;
48787
48788   arg1 = (Dali::CameraActor *)jarg1;
48789   {
48790     try {
48791       result = (float)(arg1)->GetFarClippingPlane();
48792     } catch (std::out_of_range& e) {
48793       {
48794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48795       };
48796     } catch (std::exception& e) {
48797       {
48798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48799       };
48800     } catch (Dali::DaliException e) {
48801       {
48802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48803       };
48804     } catch (...) {
48805       {
48806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48807       };
48808     }
48809   }
48810
48811   jresult = result;
48812   return jresult;
48813 }
48814
48815
48816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48817   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48818   Dali::Vector3 *arg2 = 0 ;
48819
48820   arg1 = (Dali::CameraActor *)jarg1;
48821   arg2 = (Dali::Vector3 *)jarg2;
48822   if (!arg2) {
48823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48824     return ;
48825   }
48826   {
48827     try {
48828       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48829     } catch (std::out_of_range& e) {
48830       {
48831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48832       };
48833     } catch (std::exception& e) {
48834       {
48835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48836       };
48837     } catch (Dali::DaliException e) {
48838       {
48839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48840       };
48841     } catch (...) {
48842       {
48843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48844       };
48845     }
48846   }
48847
48848 }
48849
48850
48851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48852   void * jresult ;
48853   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48854   Dali::Vector3 result;
48855
48856   arg1 = (Dali::CameraActor *)jarg1;
48857   {
48858     try {
48859       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48860     } catch (std::out_of_range& e) {
48861       {
48862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48863       };
48864     } catch (std::exception& e) {
48865       {
48866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48867       };
48868     } catch (Dali::DaliException e) {
48869       {
48870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48871       };
48872     } catch (...) {
48873       {
48874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48875       };
48876     }
48877   }
48878
48879   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48880   return jresult;
48881 }
48882
48883
48884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48885   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48886   bool arg2 ;
48887
48888   arg1 = (Dali::CameraActor *)jarg1;
48889   arg2 = jarg2 ? true : false;
48890   {
48891     try {
48892       (arg1)->SetInvertYAxis(arg2);
48893     } catch (std::out_of_range& e) {
48894       {
48895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48896       };
48897     } catch (std::exception& e) {
48898       {
48899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48900       };
48901     } catch (Dali::DaliException e) {
48902       {
48903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48904       };
48905     } catch (...) {
48906       {
48907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48908       };
48909     }
48910   }
48911
48912 }
48913
48914
48915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48916   unsigned int jresult ;
48917   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48918   bool result;
48919
48920   arg1 = (Dali::CameraActor *)jarg1;
48921   {
48922     try {
48923       result = (bool)(arg1)->GetInvertYAxis();
48924     } catch (std::out_of_range& e) {
48925       {
48926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48927       };
48928     } catch (std::exception& e) {
48929       {
48930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48931       };
48932     } catch (Dali::DaliException e) {
48933       {
48934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48935       };
48936     } catch (...) {
48937       {
48938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48939       };
48940     }
48941   }
48942
48943   jresult = result;
48944   return jresult;
48945 }
48946
48947
48948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48949   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48950   Dali::Size *arg2 = 0 ;
48951
48952   arg1 = (Dali::CameraActor *)jarg1;
48953   arg2 = (Dali::Size *)jarg2;
48954   if (!arg2) {
48955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48956     return ;
48957   }
48958   {
48959     try {
48960       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48961     } catch (std::out_of_range& e) {
48962       {
48963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48964       };
48965     } catch (std::exception& e) {
48966       {
48967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48968       };
48969     } catch (Dali::DaliException e) {
48970       {
48971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48972       };
48973     } catch (...) {
48974       {
48975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48976       };
48977     }
48978   }
48979
48980 }
48981
48982
48983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48984   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48985   Dali::Size *arg2 = 0 ;
48986
48987   arg1 = (Dali::CameraActor *)jarg1;
48988   arg2 = (Dali::Size *)jarg2;
48989   if (!arg2) {
48990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48991     return ;
48992   }
48993   {
48994     try {
48995       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48996     } catch (std::out_of_range& e) {
48997       {
48998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48999       };
49000     } catch (std::exception& e) {
49001       {
49002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49003       };
49004     } catch (Dali::DaliException e) {
49005       {
49006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49007       };
49008     } catch (...) {
49009       {
49010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49011       };
49012     }
49013   }
49014
49015 }
49016
49017
49018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49019   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49020   float arg2 ;
49021   float arg3 ;
49022   float arg4 ;
49023   float arg5 ;
49024   float arg6 ;
49025   float arg7 ;
49026
49027   arg1 = (Dali::CameraActor *)jarg1;
49028   arg2 = (float)jarg2;
49029   arg3 = (float)jarg3;
49030   arg4 = (float)jarg4;
49031   arg5 = (float)jarg5;
49032   arg6 = (float)jarg6;
49033   arg7 = (float)jarg7;
49034   {
49035     try {
49036       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49037     } catch (std::out_of_range& e) {
49038       {
49039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49040       };
49041     } catch (std::exception& e) {
49042       {
49043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49044       };
49045     } catch (Dali::DaliException e) {
49046       {
49047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49048       };
49049     } catch (...) {
49050       {
49051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49052       };
49053     }
49054   }
49055
49056 }
49057
49058
49059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49060   void * jresult ;
49061   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49062
49063   {
49064     try {
49065       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49066     } catch (std::out_of_range& e) {
49067       {
49068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49069       };
49070     } catch (std::exception& e) {
49071       {
49072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49073       };
49074     } catch (Dali::DaliException e) {
49075       {
49076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49077       };
49078     } catch (...) {
49079       {
49080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49081       };
49082     }
49083   }
49084
49085   jresult = (void *)result;
49086   return jresult;
49087 }
49088
49089
49090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49091   void * jresult ;
49092   std::string arg1 ;
49093   Dali::Property::Value arg2 ;
49094   Dali::Property::Value *argp2 ;
49095   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49096
49097   if (!jarg1) {
49098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49099     return 0;
49100   }
49101   (&arg1)->assign(jarg1);
49102   argp2 = (Dali::Property::Value *)jarg2;
49103   if (!argp2) {
49104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49105     return 0;
49106   }
49107   arg2 = *argp2;
49108   {
49109     try {
49110       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49111     } catch (std::out_of_range& e) {
49112       {
49113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49114       };
49115     } catch (std::exception& e) {
49116       {
49117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49118       };
49119     } catch (Dali::DaliException e) {
49120       {
49121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49122       };
49123     } catch (...) {
49124       {
49125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49126       };
49127     }
49128   }
49129
49130   jresult = (void *)result;
49131   return jresult;
49132 }
49133
49134
49135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49136   void * jresult ;
49137   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49138   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49139
49140   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49141   if (!arg1) {
49142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49143     return 0;
49144   }
49145   {
49146     try {
49147       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);
49148     } catch (std::out_of_range& e) {
49149       {
49150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49151       };
49152     } catch (std::exception& e) {
49153       {
49154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49155       };
49156     } catch (Dali::DaliException e) {
49157       {
49158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49159       };
49160     } catch (...) {
49161       {
49162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49163       };
49164     }
49165   }
49166
49167   jresult = (void *)result;
49168   return jresult;
49169 }
49170
49171
49172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49173   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49174   std::string *arg2 = 0 ;
49175
49176   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49177   if (!jarg2) {
49178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49179     return ;
49180   }
49181   std::string arg2_str(jarg2);
49182   arg2 = &arg2_str;
49183   if (arg1) (arg1)->first = *arg2;
49184
49185   //argout typemap for const std::string&
49186
49187 }
49188
49189
49190 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49191   char * jresult ;
49192   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49193   std::string *result = 0 ;
49194
49195   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49196   result = (std::string *) & ((arg1)->first);
49197   jresult = SWIG_csharp_string_callback(result->c_str());
49198   return jresult;
49199 }
49200
49201
49202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49203   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49204   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49205
49206   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49207   arg2 = (Dali::Property::Value *)jarg2;
49208   if (arg1) (arg1)->second = *arg2;
49209 }
49210
49211
49212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49213   void * jresult ;
49214   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49215   Dali::Property::Value *result = 0 ;
49216
49217   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49218   result = (Dali::Property::Value *)& ((arg1)->second);
49219   jresult = (void *)result;
49220   return jresult;
49221 }
49222
49223
49224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49225   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49226
49227   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49228   {
49229     try {
49230       delete arg1;
49231     } catch (std::out_of_range& e) {
49232       {
49233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49234       };
49235     } catch (std::exception& e) {
49236       {
49237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49238       };
49239     } catch (Dali::DaliException e) {
49240       {
49241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49242       };
49243     } catch (...) {
49244       {
49245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49246       };
49247     }
49248   }
49249
49250 }
49251
49252
49253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49254   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49255
49256   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49257   {
49258     try {
49259       (arg1)->clear();
49260     } catch (std::out_of_range& e) {
49261       {
49262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49263       };
49264     } catch (std::exception& e) {
49265       {
49266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49267       };
49268     } catch (Dali::DaliException e) {
49269       {
49270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49271       };
49272     } catch (...) {
49273       {
49274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49275       };
49276     }
49277   }
49278
49279 }
49280
49281
49282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49283   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49284   Dali::TouchPoint *arg2 = 0 ;
49285
49286   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49287   arg2 = (Dali::TouchPoint *)jarg2;
49288   if (!arg2) {
49289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49290     return ;
49291   }
49292   {
49293     try {
49294       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49295     } catch (std::out_of_range& e) {
49296       {
49297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49298       };
49299     } catch (std::exception& e) {
49300       {
49301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49302       };
49303     } catch (Dali::DaliException e) {
49304       {
49305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49306       };
49307     } catch (...) {
49308       {
49309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49310       };
49311     }
49312   }
49313
49314 }
49315
49316
49317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49318   unsigned long jresult ;
49319   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49320   std::vector< Dali::TouchPoint >::size_type result;
49321
49322   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49323   {
49324     try {
49325       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49326     } catch (std::out_of_range& e) {
49327       {
49328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49329       };
49330     } catch (std::exception& e) {
49331       {
49332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49333       };
49334     } catch (Dali::DaliException e) {
49335       {
49336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49337       };
49338     } catch (...) {
49339       {
49340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49341       };
49342     }
49343   }
49344
49345   jresult = (unsigned long)result;
49346   return jresult;
49347 }
49348
49349
49350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49351   unsigned long jresult ;
49352   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49353   std::vector< Dali::TouchPoint >::size_type result;
49354
49355   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49356   {
49357     try {
49358       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49359     } catch (std::out_of_range& e) {
49360       {
49361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49362       };
49363     } catch (std::exception& e) {
49364       {
49365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49366       };
49367     } catch (Dali::DaliException e) {
49368       {
49369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49370       };
49371     } catch (...) {
49372       {
49373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49374       };
49375     }
49376   }
49377
49378   jresult = (unsigned long)result;
49379   return jresult;
49380 }
49381
49382
49383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49384   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49385   std::vector< Dali::TouchPoint >::size_type arg2 ;
49386
49387   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49388   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49389   {
49390     try {
49391       (arg1)->reserve(arg2);
49392     } catch (std::out_of_range& e) {
49393       {
49394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49395       };
49396     } catch (std::exception& e) {
49397       {
49398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49399       };
49400     } catch (Dali::DaliException e) {
49401       {
49402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49403       };
49404     } catch (...) {
49405       {
49406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49407       };
49408     }
49409   }
49410
49411 }
49412
49413
49414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49415   void * jresult ;
49416   std::vector< Dali::TouchPoint > *result = 0 ;
49417
49418   {
49419     try {
49420       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49421     } catch (std::out_of_range& e) {
49422       {
49423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49424       };
49425     } catch (std::exception& e) {
49426       {
49427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49428       };
49429     } catch (Dali::DaliException e) {
49430       {
49431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49432       };
49433     } catch (...) {
49434       {
49435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49436       };
49437     }
49438   }
49439
49440   jresult = (void *)result;
49441   return jresult;
49442 }
49443
49444
49445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49446   void * jresult ;
49447   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49448   std::vector< Dali::TouchPoint > *result = 0 ;
49449
49450   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49451   if (!arg1) {
49452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49453     return 0;
49454   }
49455   {
49456     try {
49457       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49458     } catch (std::out_of_range& e) {
49459       {
49460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49461       };
49462     } catch (std::exception& e) {
49463       {
49464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49465       };
49466     } catch (Dali::DaliException e) {
49467       {
49468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49469       };
49470     } catch (...) {
49471       {
49472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49473       };
49474     }
49475   }
49476
49477   jresult = (void *)result;
49478   return jresult;
49479 }
49480
49481
49482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49483   void * jresult ;
49484   int arg1 ;
49485   std::vector< Dali::TouchPoint > *result = 0 ;
49486
49487   arg1 = (int)jarg1;
49488   {
49489     try {
49490       try {
49491         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49492       }
49493       catch(std::out_of_range &_e) {
49494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49495         return 0;
49496       }
49497
49498     } catch (std::out_of_range& e) {
49499       {
49500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49501       };
49502     } catch (std::exception& e) {
49503       {
49504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49505       };
49506     } catch (Dali::DaliException e) {
49507       {
49508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49509       };
49510     } catch (...) {
49511       {
49512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49513       };
49514     }
49515   }
49516
49517   jresult = (void *)result;
49518   return jresult;
49519 }
49520
49521
49522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49523   void * jresult ;
49524   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49525   int arg2 ;
49526   SwigValueWrapper< Dali::TouchPoint > result;
49527
49528   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49529   arg2 = (int)jarg2;
49530   {
49531     try {
49532       try {
49533         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49534       }
49535       catch(std::out_of_range &_e) {
49536         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49537         return 0;
49538       }
49539
49540     } catch (std::out_of_range& e) {
49541       {
49542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49543       };
49544     } catch (std::exception& e) {
49545       {
49546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49547       };
49548     } catch (Dali::DaliException e) {
49549       {
49550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49551       };
49552     } catch (...) {
49553       {
49554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49555       };
49556     }
49557   }
49558
49559   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49560   return jresult;
49561 }
49562
49563
49564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49565   void * jresult ;
49566   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49567   int arg2 ;
49568   Dali::TouchPoint *result = 0 ;
49569
49570   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49571   arg2 = (int)jarg2;
49572   {
49573     try {
49574       try {
49575         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49576       }
49577       catch(std::out_of_range &_e) {
49578         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49579         return 0;
49580       }
49581
49582     } catch (std::out_of_range& e) {
49583       {
49584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49585       };
49586     } catch (std::exception& e) {
49587       {
49588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49589       };
49590     } catch (Dali::DaliException e) {
49591       {
49592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49593       };
49594     } catch (...) {
49595       {
49596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49597       };
49598     }
49599   }
49600
49601   jresult = (void *)result;
49602   return jresult;
49603 }
49604
49605
49606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49607   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49608   int arg2 ;
49609   Dali::TouchPoint *arg3 = 0 ;
49610
49611   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49612   arg2 = (int)jarg2;
49613   arg3 = (Dali::TouchPoint *)jarg3;
49614   if (!arg3) {
49615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49616     return ;
49617   }
49618   {
49619     try {
49620       try {
49621         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49622       }
49623       catch(std::out_of_range &_e) {
49624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49625         return ;
49626       }
49627
49628     } catch (std::out_of_range& e) {
49629       {
49630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49631       };
49632     } catch (std::exception& e) {
49633       {
49634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49635       };
49636     } catch (Dali::DaliException e) {
49637       {
49638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49639       };
49640     } catch (...) {
49641       {
49642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49643       };
49644     }
49645   }
49646
49647 }
49648
49649
49650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49651   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49652   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49653
49654   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49655   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49656   if (!arg2) {
49657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49658     return ;
49659   }
49660   {
49661     try {
49662       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49663     } catch (std::out_of_range& e) {
49664       {
49665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49666       };
49667     } catch (std::exception& e) {
49668       {
49669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49670       };
49671     } catch (Dali::DaliException e) {
49672       {
49673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49674       };
49675     } catch (...) {
49676       {
49677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49678       };
49679     }
49680   }
49681
49682 }
49683
49684
49685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49686   void * jresult ;
49687   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49688   int arg2 ;
49689   int arg3 ;
49690   std::vector< Dali::TouchPoint > *result = 0 ;
49691
49692   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49693   arg2 = (int)jarg2;
49694   arg3 = (int)jarg3;
49695   {
49696     try {
49697       try {
49698         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49699       }
49700       catch(std::out_of_range &_e) {
49701         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49702         return 0;
49703       }
49704       catch(std::invalid_argument &_e) {
49705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49706         return 0;
49707       }
49708
49709     } catch (std::out_of_range& e) {
49710       {
49711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49712       };
49713     } catch (std::exception& e) {
49714       {
49715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49716       };
49717     } catch (Dali::DaliException e) {
49718       {
49719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49720       };
49721     } catch (...) {
49722       {
49723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49724       };
49725     }
49726   }
49727
49728   jresult = (void *)result;
49729   return jresult;
49730 }
49731
49732
49733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49734   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49735   int arg2 ;
49736   Dali::TouchPoint *arg3 = 0 ;
49737
49738   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49739   arg2 = (int)jarg2;
49740   arg3 = (Dali::TouchPoint *)jarg3;
49741   if (!arg3) {
49742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49743     return ;
49744   }
49745   {
49746     try {
49747       try {
49748         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49749       }
49750       catch(std::out_of_range &_e) {
49751         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49752         return ;
49753       }
49754
49755     } catch (std::out_of_range& e) {
49756       {
49757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49758       };
49759     } catch (std::exception& e) {
49760       {
49761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49762       };
49763     } catch (Dali::DaliException e) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49766       };
49767     } catch (...) {
49768       {
49769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49770       };
49771     }
49772   }
49773
49774 }
49775
49776
49777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49778   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49779   int arg2 ;
49780   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49781
49782   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49783   arg2 = (int)jarg2;
49784   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49785   if (!arg3) {
49786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49787     return ;
49788   }
49789   {
49790     try {
49791       try {
49792         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49793       }
49794       catch(std::out_of_range &_e) {
49795         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49796         return ;
49797       }
49798
49799     } catch (std::out_of_range& e) {
49800       {
49801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49802       };
49803     } catch (std::exception& e) {
49804       {
49805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49806       };
49807     } catch (Dali::DaliException e) {
49808       {
49809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49810       };
49811     } catch (...) {
49812       {
49813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49814       };
49815     }
49816   }
49817
49818 }
49819
49820
49821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49822   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49823   int arg2 ;
49824
49825   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49826   arg2 = (int)jarg2;
49827   {
49828     try {
49829       try {
49830         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49831       }
49832       catch(std::out_of_range &_e) {
49833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49834         return ;
49835       }
49836
49837     } catch (std::out_of_range& e) {
49838       {
49839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49840       };
49841     } catch (std::exception& e) {
49842       {
49843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49844       };
49845     } catch (Dali::DaliException e) {
49846       {
49847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49848       };
49849     } catch (...) {
49850       {
49851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49852       };
49853     }
49854   }
49855
49856 }
49857
49858
49859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49860   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49861   int arg2 ;
49862   int arg3 ;
49863
49864   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49865   arg2 = (int)jarg2;
49866   arg3 = (int)jarg3;
49867   {
49868     try {
49869       try {
49870         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49871       }
49872       catch(std::out_of_range &_e) {
49873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49874         return ;
49875       }
49876       catch(std::invalid_argument &_e) {
49877         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49878         return ;
49879       }
49880
49881     } catch (std::out_of_range& e) {
49882       {
49883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49884       };
49885     } catch (std::exception& e) {
49886       {
49887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49888       };
49889     } catch (Dali::DaliException e) {
49890       {
49891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49892       };
49893     } catch (...) {
49894       {
49895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49896       };
49897     }
49898   }
49899
49900 }
49901
49902
49903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49904   void * jresult ;
49905   Dali::TouchPoint *arg1 = 0 ;
49906   int arg2 ;
49907   std::vector< Dali::TouchPoint > *result = 0 ;
49908
49909   arg1 = (Dali::TouchPoint *)jarg1;
49910   if (!arg1) {
49911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49912     return 0;
49913   }
49914   arg2 = (int)jarg2;
49915   {
49916     try {
49917       try {
49918         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49919       }
49920       catch(std::out_of_range &_e) {
49921         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49922         return 0;
49923       }
49924
49925     } catch (std::out_of_range& e) {
49926       {
49927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49928       };
49929     } catch (std::exception& e) {
49930       {
49931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49932       };
49933     } catch (Dali::DaliException e) {
49934       {
49935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49936       };
49937     } catch (...) {
49938       {
49939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49940       };
49941     }
49942   }
49943
49944   jresult = (void *)result;
49945   return jresult;
49946 }
49947
49948
49949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49950   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49951
49952   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49953   {
49954     try {
49955       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49956     } catch (std::out_of_range& e) {
49957       {
49958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49959       };
49960     } catch (std::exception& e) {
49961       {
49962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49963       };
49964     } catch (Dali::DaliException e) {
49965       {
49966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49967       };
49968     } catch (...) {
49969       {
49970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49971       };
49972     }
49973   }
49974
49975 }
49976
49977
49978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49979   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49980   int arg2 ;
49981   int arg3 ;
49982
49983   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49984   arg2 = (int)jarg2;
49985   arg3 = (int)jarg3;
49986   {
49987     try {
49988       try {
49989         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49990       }
49991       catch(std::out_of_range &_e) {
49992         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49993         return ;
49994       }
49995       catch(std::invalid_argument &_e) {
49996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49997         return ;
49998       }
49999
50000     } catch (std::out_of_range& e) {
50001       {
50002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50003       };
50004     } catch (std::exception& e) {
50005       {
50006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50007       };
50008     } catch (Dali::DaliException e) {
50009       {
50010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50011       };
50012     } catch (...) {
50013       {
50014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50015       };
50016     }
50017   }
50018
50019 }
50020
50021
50022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50023   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50024   int arg2 ;
50025   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50026
50027   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50028   arg2 = (int)jarg2;
50029   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50030   if (!arg3) {
50031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50032     return ;
50033   }
50034   {
50035     try {
50036       try {
50037         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50038       }
50039       catch(std::out_of_range &_e) {
50040         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50041         return ;
50042       }
50043
50044     } catch (std::out_of_range& e) {
50045       {
50046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50047       };
50048     } catch (std::exception& e) {
50049       {
50050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50051       };
50052     } catch (Dali::DaliException e) {
50053       {
50054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50055       };
50056     } catch (...) {
50057       {
50058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50059       };
50060     }
50061   }
50062
50063 }
50064
50065
50066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50067   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50068
50069   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50070   {
50071     try {
50072       delete arg1;
50073     } catch (std::out_of_range& e) {
50074       {
50075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50076       };
50077     } catch (std::exception& e) {
50078       {
50079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50080       };
50081     } catch (Dali::DaliException e) {
50082       {
50083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50084       };
50085     } catch (...) {
50086       {
50087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50088       };
50089     }
50090   }
50091
50092 }
50093
50094
50095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50096   void * jresult ;
50097   Dali::Rect< int > *result = 0 ;
50098
50099   {
50100     try {
50101       result = (Dali::Rect< int > *)new Dali::Rect< int >();
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_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50127   void * jresult ;
50128   int arg1 ;
50129   int arg2 ;
50130   int arg3 ;
50131   int arg4 ;
50132   Dali::Rect< int > *result = 0 ;
50133
50134   arg1 = (int)jarg1;
50135   arg2 = (int)jarg2;
50136   arg3 = (int)jarg3;
50137   arg4 = (int)jarg4;
50138   {
50139     try {
50140       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50141     } catch (std::out_of_range& e) {
50142       {
50143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50144       };
50145     } catch (std::exception& e) {
50146       {
50147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50148       };
50149     } catch (Dali::DaliException e) {
50150       {
50151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50152       };
50153     } catch (...) {
50154       {
50155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50156       };
50157     }
50158   }
50159
50160   jresult = (void *)result;
50161   return jresult;
50162 }
50163
50164
50165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50166   void * jresult ;
50167   Dali::Rect< int > *arg1 = 0 ;
50168   Dali::Rect< int > *result = 0 ;
50169
50170   arg1 = (Dali::Rect< int > *)jarg1;
50171   if (!arg1) {
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 > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
50203   void * jresult ;
50204   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50205   Dali::Rect< int > *arg2 = 0 ;
50206   Dali::Rect< int > *result = 0 ;
50207
50208   arg1 = (Dali::Rect< int > *)jarg1;
50209   arg2 = (Dali::Rect< int > *)jarg2;
50210   if (!arg2) {
50211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50212     return 0;
50213   }
50214   {
50215     try {
50216       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50217     } catch (std::out_of_range& e) {
50218       {
50219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50220       };
50221     } catch (std::exception& e) {
50222       {
50223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50224       };
50225     } catch (Dali::DaliException e) {
50226       {
50227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50228       };
50229     } catch (...) {
50230       {
50231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50232       };
50233     }
50234   }
50235
50236   jresult = (void *)result;
50237   return jresult;
50238 }
50239
50240
50241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50242   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50243   int arg2 ;
50244   int arg3 ;
50245   int arg4 ;
50246   int arg5 ;
50247
50248   arg1 = (Dali::Rect< int > *)jarg1;
50249   arg2 = (int)jarg2;
50250   arg3 = (int)jarg3;
50251   arg4 = (int)jarg4;
50252   arg5 = (int)jarg5;
50253   {
50254     try {
50255       (arg1)->Set(arg2,arg3,arg4,arg5);
50256     } catch (std::out_of_range& e) {
50257       {
50258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50259       };
50260     } catch (std::exception& e) {
50261       {
50262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50263       };
50264     } catch (Dali::DaliException e) {
50265       {
50266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50267       };
50268     } catch (...) {
50269       {
50270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50271       };
50272     }
50273   }
50274
50275 }
50276
50277
50278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50279   unsigned int jresult ;
50280   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50281   bool result;
50282
50283   arg1 = (Dali::Rect< int > *)jarg1;
50284   {
50285     try {
50286       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50287     } catch (std::out_of_range& e) {
50288       {
50289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50290       };
50291     } catch (std::exception& e) {
50292       {
50293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50294       };
50295     } catch (Dali::DaliException e) {
50296       {
50297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50298       };
50299     } catch (...) {
50300       {
50301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50302       };
50303     }
50304   }
50305
50306   jresult = result;
50307   return jresult;
50308 }
50309
50310
50311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50312   int jresult ;
50313   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50314   int result;
50315
50316   arg1 = (Dali::Rect< int > *)jarg1;
50317   {
50318     try {
50319       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50320     } catch (std::out_of_range& e) {
50321       {
50322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50323       };
50324     } catch (std::exception& e) {
50325       {
50326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50327       };
50328     } catch (Dali::DaliException e) {
50329       {
50330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50331       };
50332     } catch (...) {
50333       {
50334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50335       };
50336     }
50337   }
50338
50339   jresult = result;
50340   return jresult;
50341 }
50342
50343
50344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50345   int jresult ;
50346   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50347   int result;
50348
50349   arg1 = (Dali::Rect< int > *)jarg1;
50350   {
50351     try {
50352       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50353     } catch (std::out_of_range& e) {
50354       {
50355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50356       };
50357     } catch (std::exception& e) {
50358       {
50359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50360       };
50361     } catch (Dali::DaliException e) {
50362       {
50363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50364       };
50365     } catch (...) {
50366       {
50367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50368       };
50369     }
50370   }
50371
50372   jresult = result;
50373   return jresult;
50374 }
50375
50376
50377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50378   int jresult ;
50379   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50380   int result;
50381
50382   arg1 = (Dali::Rect< int > *)jarg1;
50383   {
50384     try {
50385       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50386     } catch (std::out_of_range& e) {
50387       {
50388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50389       };
50390     } catch (std::exception& e) {
50391       {
50392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50393       };
50394     } catch (Dali::DaliException e) {
50395       {
50396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50397       };
50398     } catch (...) {
50399       {
50400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50401       };
50402     }
50403   }
50404
50405   jresult = result;
50406   return jresult;
50407 }
50408
50409
50410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50411   int jresult ;
50412   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50413   int result;
50414
50415   arg1 = (Dali::Rect< int > *)jarg1;
50416   {
50417     try {
50418       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50419     } catch (std::out_of_range& e) {
50420       {
50421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50422       };
50423     } catch (std::exception& e) {
50424       {
50425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50426       };
50427     } catch (Dali::DaliException e) {
50428       {
50429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50430       };
50431     } catch (...) {
50432       {
50433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50434       };
50435     }
50436   }
50437
50438   jresult = result;
50439   return jresult;
50440 }
50441
50442
50443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50444   int jresult ;
50445   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50446   int result;
50447
50448   arg1 = (Dali::Rect< int > *)jarg1;
50449   {
50450     try {
50451       result = (int)((Dali::Rect< int > const *)arg1)->Area();
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_Intersects(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)->Intersects((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 unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50516   unsigned int jresult ;
50517   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50518   Dali::Rect< int > *arg2 = 0 ;
50519   bool result;
50520
50521   arg1 = (Dali::Rect< int > *)jarg1;
50522   arg2 = (Dali::Rect< int > *)jarg2;
50523   if (!arg2) {
50524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50525     return 0;
50526   }
50527   {
50528     try {
50529       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50530     } catch (std::out_of_range& e) {
50531       {
50532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50533       };
50534     } catch (std::exception& e) {
50535       {
50536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50537       };
50538     } catch (Dali::DaliException e) {
50539       {
50540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50541       };
50542     } catch (...) {
50543       {
50544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50545       };
50546     }
50547   }
50548
50549   jresult = result;
50550   return jresult;
50551 }
50552
50553
50554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50555   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50556   int arg2 ;
50557
50558   arg1 = (Dali::Rect< int > *)jarg1;
50559   arg2 = (int)jarg2;
50560   if (arg1) (arg1)->x = arg2;
50561 }
50562
50563
50564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50565   int jresult ;
50566   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50567   int result;
50568
50569   arg1 = (Dali::Rect< int > *)jarg1;
50570   result = (int) ((arg1)->x);
50571   jresult = result;
50572   return jresult;
50573 }
50574
50575
50576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50577   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50578   int arg2 ;
50579
50580   arg1 = (Dali::Rect< int > *)jarg1;
50581   arg2 = (int)jarg2;
50582   if (arg1) (arg1)->left = arg2;
50583 }
50584
50585
50586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50587   int jresult ;
50588   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50589   int result;
50590
50591   arg1 = (Dali::Rect< int > *)jarg1;
50592   result = (int) ((arg1)->left);
50593   jresult = result;
50594   return jresult;
50595 }
50596
50597
50598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50599   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50600   int arg2 ;
50601
50602   arg1 = (Dali::Rect< int > *)jarg1;
50603   arg2 = (int)jarg2;
50604   if (arg1) (arg1)->y = arg2;
50605 }
50606
50607
50608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50609   int jresult ;
50610   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50611   int result;
50612
50613   arg1 = (Dali::Rect< int > *)jarg1;
50614   result = (int) ((arg1)->y);
50615   jresult = result;
50616   return jresult;
50617 }
50618
50619
50620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50621   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50622   int arg2 ;
50623
50624   arg1 = (Dali::Rect< int > *)jarg1;
50625   arg2 = (int)jarg2;
50626   if (arg1) (arg1)->right = arg2;
50627 }
50628
50629
50630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50631   int jresult ;
50632   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50633   int result;
50634
50635   arg1 = (Dali::Rect< int > *)jarg1;
50636   result = (int) ((arg1)->right);
50637   jresult = result;
50638   return jresult;
50639 }
50640
50641
50642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50643   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50644   int arg2 ;
50645
50646   arg1 = (Dali::Rect< int > *)jarg1;
50647   arg2 = (int)jarg2;
50648   if (arg1) (arg1)->width = arg2;
50649 }
50650
50651
50652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50653   int jresult ;
50654   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50655   int result;
50656
50657   arg1 = (Dali::Rect< int > *)jarg1;
50658   result = (int) ((arg1)->width);
50659   jresult = result;
50660   return jresult;
50661 }
50662
50663
50664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50665   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50666   int arg2 ;
50667
50668   arg1 = (Dali::Rect< int > *)jarg1;
50669   arg2 = (int)jarg2;
50670   if (arg1) (arg1)->bottom = arg2;
50671 }
50672
50673
50674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50675   int jresult ;
50676   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50677   int result;
50678
50679   arg1 = (Dali::Rect< int > *)jarg1;
50680   result = (int) ((arg1)->bottom);
50681   jresult = result;
50682   return jresult;
50683 }
50684
50685
50686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50687   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50688   int arg2 ;
50689
50690   arg1 = (Dali::Rect< int > *)jarg1;
50691   arg2 = (int)jarg2;
50692   if (arg1) (arg1)->height = arg2;
50693 }
50694
50695
50696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50697   int jresult ;
50698   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50699   int result;
50700
50701   arg1 = (Dali::Rect< int > *)jarg1;
50702   result = (int) ((arg1)->height);
50703   jresult = result;
50704   return jresult;
50705 }
50706
50707
50708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50709   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50710   int arg2 ;
50711
50712   arg1 = (Dali::Rect< int > *)jarg1;
50713   arg2 = (int)jarg2;
50714   if (arg1) (arg1)->top = arg2;
50715 }
50716
50717
50718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50719   int jresult ;
50720   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50721   int result;
50722
50723   arg1 = (Dali::Rect< int > *)jarg1;
50724   result = (int) ((arg1)->top);
50725   jresult = result;
50726   return jresult;
50727 }
50728
50729
50730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50731   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50732
50733   arg1 = (Dali::Rect< int > *)jarg1;
50734   {
50735     try {
50736       delete arg1;
50737     } catch (std::out_of_range& e) {
50738       {
50739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50740       };
50741     } catch (std::exception& e) {
50742       {
50743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50744       };
50745     } catch (Dali::DaliException e) {
50746       {
50747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50748       };
50749     } catch (...) {
50750       {
50751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50752       };
50753     }
50754   }
50755
50756 }
50757
50758
50759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50760   void * jresult ;
50761   Dali::Rect< float > *result = 0 ;
50762
50763   {
50764     try {
50765       result = (Dali::Rect< float > *)new Dali::Rect< float >();
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_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50791   void * jresult ;
50792   float arg1 ;
50793   float arg2 ;
50794   float arg3 ;
50795   float arg4 ;
50796   Dali::Rect< float > *result = 0 ;
50797
50798   arg1 = (float)jarg1;
50799   arg2 = (float)jarg2;
50800   arg3 = (float)jarg4;
50801   arg4 = (float)jarg3;
50802   {
50803     try {
50804       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50805     } catch (std::out_of_range& e) {
50806       {
50807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50808       };
50809     } catch (std::exception& e) {
50810       {
50811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50812       };
50813     } catch (Dali::DaliException e) {
50814       {
50815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50816       };
50817     } catch (...) {
50818       {
50819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50820       };
50821     }
50822   }
50823
50824   jresult = (void *)result;
50825   return jresult;
50826 }
50827
50828
50829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50830   void * jresult ;
50831   Dali::Rect< float > *arg1 = 0 ;
50832   Dali::Rect< float > *result = 0 ;
50833
50834   arg1 = (Dali::Rect< float > *)jarg1;
50835   if (!arg1) {
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 > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
50867   void * jresult ;
50868   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50869   Dali::Rect< float > *arg2 = 0 ;
50870   Dali::Rect< float > *result = 0 ;
50871
50872   arg1 = (Dali::Rect< float > *)jarg1;
50873   arg2 = (Dali::Rect< float > *)jarg2;
50874   if (!arg2) {
50875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50876     return 0;
50877   }
50878   {
50879     try {
50880       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50881     } catch (std::out_of_range& e) {
50882       {
50883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50884       };
50885     } catch (std::exception& e) {
50886       {
50887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50888       };
50889     } catch (Dali::DaliException e) {
50890       {
50891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50892       };
50893     } catch (...) {
50894       {
50895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50896       };
50897     }
50898   }
50899
50900   jresult = (void *)result;
50901   return jresult;
50902 }
50903
50904
50905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50906   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50907   float arg2 ;
50908   float arg3 ;
50909   float arg4 ;
50910   float arg5 ;
50911
50912   arg1 = (Dali::Rect< float > *)jarg1;
50913   arg2 = (float)jarg2;
50914   arg3 = (float)jarg3;
50915   arg4 = (float)jarg5;
50916   arg5 = (float)jarg4;
50917   {
50918     try {
50919       (arg1)->Set(arg2,arg3,arg4,arg5);
50920     } catch (std::out_of_range& e) {
50921       {
50922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50923       };
50924     } catch (std::exception& e) {
50925       {
50926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50927       };
50928     } catch (Dali::DaliException e) {
50929       {
50930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50931       };
50932     } catch (...) {
50933       {
50934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50935       };
50936     }
50937   }
50938
50939 }
50940
50941
50942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50943   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50944   float arg2 ;
50945
50946   arg1 = (Dali::Rect< float > *)jarg1;
50947   arg2 = (float)jarg2;
50948   if (arg1) (arg1)->left = arg2;
50949 }
50950
50951
50952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50953   float jresult ;
50954   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50955   float result;
50956
50957   arg1 = (Dali::Rect< float > *)jarg1;
50958   result = (float) ((arg1)->left);
50959   jresult = result;
50960   return jresult;
50961 }
50962
50963
50964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50965   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50966   float arg2 ;
50967
50968   arg1 = (Dali::Rect< float > *)jarg1;
50969   arg2 = (float)jarg2;
50970   if (arg1) (arg1)->left = arg2;
50971 }
50972
50973
50974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50975   float jresult ;
50976   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50977   float result;
50978
50979   arg1 = (Dali::Rect< float > *)jarg1;
50980   result = (float) ((arg1)->left);
50981   jresult = result;
50982   return jresult;
50983 }
50984
50985
50986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50987   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50988   float arg2 ;
50989
50990   arg1 = (Dali::Rect< float > *)jarg1;
50991   arg2 = (float)jarg2;
50992   if (arg1) (arg1)->right = arg2;
50993 }
50994
50995
50996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50997   float jresult ;
50998   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50999   float result;
51000
51001   arg1 = (Dali::Rect< float > *)jarg1;
51002   result = (float) ((arg1)->right);
51003   jresult = result;
51004   return jresult;
51005 }
51006
51007
51008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51009   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51010   float arg2 ;
51011
51012   arg1 = (Dali::Rect< float > *)jarg1;
51013   arg2 = (float)jarg2;
51014   if (arg1) (arg1)->right = arg2;
51015 }
51016
51017
51018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51019   float jresult ;
51020   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51021   float result;
51022
51023   arg1 = (Dali::Rect< float > *)jarg1;
51024   result = (float) ((arg1)->right);
51025   jresult = result;
51026   return jresult;
51027 }
51028
51029
51030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51031   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51032   float arg2 ;
51033
51034   arg1 = (Dali::Rect< float > *)jarg1;
51035   arg2 = (float)jarg2;
51036   if (arg1) (arg1)->bottom = arg2;
51037 }
51038
51039
51040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51041   float jresult ;
51042   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51043   float result;
51044
51045   arg1 = (Dali::Rect< float > *)jarg1;
51046   result = (float) ((arg1)->bottom);
51047   jresult = result;
51048   return jresult;
51049 }
51050
51051
51052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51053   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51054   float arg2 ;
51055
51056   arg1 = (Dali::Rect< float > *)jarg1;
51057   arg2 = (float)jarg2;
51058   if (arg1) (arg1)->top = arg2;
51059 }
51060
51061
51062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51063   float jresult ;
51064   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51065   float result;
51066
51067   arg1 = (Dali::Rect< float > *)jarg1;
51068   result = (float) ((arg1)->top);
51069   jresult = result;
51070   return jresult;
51071 }
51072
51073
51074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51075   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51076
51077   arg1 = (Dali::Rect< float > *)jarg1;
51078   {
51079     try {
51080       delete arg1;
51081     } catch (std::out_of_range& e) {
51082       {
51083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51084       };
51085     } catch (std::exception& e) {
51086       {
51087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51088       };
51089     } catch (Dali::DaliException e) {
51090       {
51091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51092       };
51093     } catch (...) {
51094       {
51095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51096       };
51097     }
51098   }
51099
51100 }
51101
51102
51103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51104   int jresult ;
51105   int result;
51106
51107   result = (int)Dali::Vector< int >::BaseType;
51108   jresult = (int)result;
51109   return jresult;
51110 }
51111
51112
51113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51114   void * jresult ;
51115   Dali::Vector< int > *result = 0 ;
51116
51117   {
51118     try {
51119       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51120     } catch (std::out_of_range& e) {
51121       {
51122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51123       };
51124     } catch (std::exception& e) {
51125       {
51126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51127       };
51128     } catch (Dali::DaliException e) {
51129       {
51130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51131       };
51132     } catch (...) {
51133       {
51134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51135       };
51136     }
51137   }
51138
51139   jresult = (void *)result;
51140   return jresult;
51141 }
51142
51143
51144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51145   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51146
51147   arg1 = (Dali::Vector< int > *)jarg1;
51148   {
51149     try {
51150       delete arg1;
51151     } catch (std::out_of_range& e) {
51152       {
51153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51154       };
51155     } catch (std::exception& e) {
51156       {
51157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51158       };
51159     } catch (Dali::DaliException e) {
51160       {
51161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51162       };
51163     } catch (...) {
51164       {
51165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51166       };
51167     }
51168   }
51169
51170 }
51171
51172
51173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51174   void * jresult ;
51175   Dali::Vector< int > *arg1 = 0 ;
51176   Dali::Vector< int > *result = 0 ;
51177
51178   arg1 = (Dali::Vector< int > *)jarg1;
51179   if (!arg1) {
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 > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
51211   void * jresult ;
51212   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51213   Dali::Vector< int > *arg2 = 0 ;
51214   Dali::Vector< int > *result = 0 ;
51215
51216   arg1 = (Dali::Vector< int > *)jarg1;
51217   arg2 = (Dali::Vector< int > *)jarg2;
51218   if (!arg2) {
51219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51220     return 0;
51221   }
51222   {
51223     try {
51224       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51225     } catch (std::out_of_range& e) {
51226       {
51227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51228       };
51229     } catch (std::exception& e) {
51230       {
51231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51232       };
51233     } catch (Dali::DaliException e) {
51234       {
51235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51236       };
51237     } catch (...) {
51238       {
51239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51240       };
51241     }
51242   }
51243
51244   jresult = (void *)result;
51245   return jresult;
51246 }
51247
51248
51249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51250   void * jresult ;
51251   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51252   Dali::Vector< int >::Iterator result;
51253
51254   arg1 = (Dali::Vector< int > *)jarg1;
51255   {
51256     try {
51257       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51258     } catch (std::out_of_range& e) {
51259       {
51260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51261       };
51262     } catch (std::exception& e) {
51263       {
51264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51265       };
51266     } catch (Dali::DaliException e) {
51267       {
51268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51269       };
51270     } catch (...) {
51271       {
51272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51273       };
51274     }
51275   }
51276
51277   jresult = (void *)result;
51278   return jresult;
51279 }
51280
51281
51282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51283   void * jresult ;
51284   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51285   Dali::Vector< int >::Iterator result;
51286
51287   arg1 = (Dali::Vector< int > *)jarg1;
51288   {
51289     try {
51290       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51291     } catch (std::out_of_range& e) {
51292       {
51293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51294       };
51295     } catch (std::exception& e) {
51296       {
51297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51298       };
51299     } catch (Dali::DaliException e) {
51300       {
51301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51302       };
51303     } catch (...) {
51304       {
51305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51306       };
51307     }
51308   }
51309
51310   jresult = (void *)result;
51311   return jresult;
51312 }
51313
51314
51315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51316   void * jresult ;
51317   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51318   Dali::Vector< int >::SizeType arg2 ;
51319   Dali::Vector< int >::ItemType *result = 0 ;
51320
51321   arg1 = (Dali::Vector< int > *)jarg1;
51322   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51323   {
51324     try {
51325       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51326     } catch (std::out_of_range& e) {
51327       {
51328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51329       };
51330     } catch (std::exception& e) {
51331       {
51332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51333       };
51334     } catch (Dali::DaliException e) {
51335       {
51336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51337       };
51338     } catch (...) {
51339       {
51340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51341       };
51342     }
51343   }
51344
51345   jresult = (void *)result;
51346   return jresult;
51347 }
51348
51349
51350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51351   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51352   Dali::Vector< int >::ItemType *arg2 = 0 ;
51353   Dali::Vector< int >::ItemType temp2 ;
51354
51355   arg1 = (Dali::Vector< int > *)jarg1;
51356   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51357   arg2 = &temp2;
51358   {
51359     try {
51360       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51361     } catch (std::out_of_range& e) {
51362       {
51363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51364       };
51365     } catch (std::exception& e) {
51366       {
51367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51368       };
51369     } catch (Dali::DaliException e) {
51370       {
51371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51372       };
51373     } catch (...) {
51374       {
51375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51376       };
51377     }
51378   }
51379
51380 }
51381
51382
51383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51384   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51385   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51386   Dali::Vector< int >::ItemType *arg3 = 0 ;
51387   Dali::Vector< int >::ItemType temp3 ;
51388
51389   arg1 = (Dali::Vector< int > *)jarg1;
51390   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51391   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51392   arg3 = &temp3;
51393   {
51394     try {
51395       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51396     } catch (std::out_of_range& e) {
51397       {
51398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51399       };
51400     } catch (std::exception& e) {
51401       {
51402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51403       };
51404     } catch (Dali::DaliException e) {
51405       {
51406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51407       };
51408     } catch (...) {
51409       {
51410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51411       };
51412     }
51413   }
51414
51415 }
51416
51417
51418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51419   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51420   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51421   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51422   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51423
51424   arg1 = (Dali::Vector< int > *)jarg1;
51425   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51426   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51427   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51428   {
51429     try {
51430       (arg1)->Insert(arg2,arg3,arg4);
51431     } catch (std::out_of_range& e) {
51432       {
51433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51434       };
51435     } catch (std::exception& e) {
51436       {
51437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51438       };
51439     } catch (Dali::DaliException e) {
51440       {
51441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51442       };
51443     } catch (...) {
51444       {
51445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51446       };
51447     }
51448   }
51449
51450 }
51451
51452
51453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51454   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51455   Dali::Vector< int >::SizeType arg2 ;
51456
51457   arg1 = (Dali::Vector< int > *)jarg1;
51458   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51459   {
51460     try {
51461       (arg1)->Reserve(arg2);
51462     } catch (std::out_of_range& e) {
51463       {
51464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51465       };
51466     } catch (std::exception& e) {
51467       {
51468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51469       };
51470     } catch (Dali::DaliException e) {
51471       {
51472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51473       };
51474     } catch (...) {
51475       {
51476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51477       };
51478     }
51479   }
51480
51481 }
51482
51483
51484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51485   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51486   Dali::Vector< int >::SizeType arg2 ;
51487
51488   arg1 = (Dali::Vector< int > *)jarg1;
51489   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51490   {
51491     try {
51492       (arg1)->Resize(arg2);
51493     } catch (std::out_of_range& e) {
51494       {
51495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51496       };
51497     } catch (std::exception& e) {
51498       {
51499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51500       };
51501     } catch (Dali::DaliException e) {
51502       {
51503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51504       };
51505     } catch (...) {
51506       {
51507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51508       };
51509     }
51510   }
51511
51512 }
51513
51514
51515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51516   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51517   Dali::Vector< int >::SizeType arg2 ;
51518   Dali::Vector< int >::ItemType *arg3 = 0 ;
51519   Dali::Vector< int >::ItemType temp3 ;
51520
51521   arg1 = (Dali::Vector< int > *)jarg1;
51522   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51523   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51524   arg3 = &temp3;
51525   {
51526     try {
51527       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51528     } catch (std::out_of_range& e) {
51529       {
51530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51531       };
51532     } catch (std::exception& e) {
51533       {
51534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51535       };
51536     } catch (Dali::DaliException e) {
51537       {
51538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51539       };
51540     } catch (...) {
51541       {
51542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51543       };
51544     }
51545   }
51546
51547 }
51548
51549
51550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51551   void * jresult ;
51552   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51553   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51554   Dali::Vector< int >::Iterator result;
51555
51556   arg1 = (Dali::Vector< int > *)jarg1;
51557   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51558   {
51559     try {
51560       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51561     } catch (std::out_of_range& e) {
51562       {
51563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51564       };
51565     } catch (std::exception& e) {
51566       {
51567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51568       };
51569     } catch (Dali::DaliException e) {
51570       {
51571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51572       };
51573     } catch (...) {
51574       {
51575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51576       };
51577     }
51578   }
51579
51580   jresult = (void *)result;
51581   return jresult;
51582 }
51583
51584
51585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51586   void * jresult ;
51587   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51588   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51589   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51590   Dali::Vector< int >::Iterator result;
51591
51592   arg1 = (Dali::Vector< int > *)jarg1;
51593   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51594   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51595   {
51596     try {
51597       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51598     } catch (std::out_of_range& e) {
51599       {
51600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51601       };
51602     } catch (std::exception& e) {
51603       {
51604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51605       };
51606     } catch (Dali::DaliException e) {
51607       {
51608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51609       };
51610     } catch (...) {
51611       {
51612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51613       };
51614     }
51615   }
51616
51617   jresult = (void *)result;
51618   return jresult;
51619 }
51620
51621
51622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51623   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51624   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51625
51626   arg1 = (Dali::Vector< int > *)jarg1;
51627   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51628   {
51629     try {
51630       (arg1)->Remove(arg2);
51631     } catch (std::out_of_range& e) {
51632       {
51633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51634       };
51635     } catch (std::exception& e) {
51636       {
51637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51638       };
51639     } catch (Dali::DaliException e) {
51640       {
51641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51642       };
51643     } catch (...) {
51644       {
51645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51646       };
51647     }
51648   }
51649
51650 }
51651
51652
51653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51654   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51655   Dali::Vector< int > *arg2 = 0 ;
51656
51657   arg1 = (Dali::Vector< int > *)jarg1;
51658   arg2 = (Dali::Vector< int > *)jarg2;
51659   if (!arg2) {
51660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51661     return ;
51662   }
51663   {
51664     try {
51665       (arg1)->Swap(*arg2);
51666     } catch (std::out_of_range& e) {
51667       {
51668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51669       };
51670     } catch (std::exception& e) {
51671       {
51672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51673       };
51674     } catch (Dali::DaliException e) {
51675       {
51676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51677       };
51678     } catch (...) {
51679       {
51680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51681       };
51682     }
51683   }
51684
51685 }
51686
51687
51688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51689   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51690
51691   arg1 = (Dali::Vector< int > *)jarg1;
51692   {
51693     try {
51694       (arg1)->Clear();
51695     } catch (std::out_of_range& e) {
51696       {
51697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51698       };
51699     } catch (std::exception& e) {
51700       {
51701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51702       };
51703     } catch (Dali::DaliException e) {
51704       {
51705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51706       };
51707     } catch (...) {
51708       {
51709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51710       };
51711     }
51712   }
51713
51714 }
51715
51716
51717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51718   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51719
51720   arg1 = (Dali::Vector< int > *)jarg1;
51721   {
51722     try {
51723       (arg1)->Release();
51724     } catch (std::out_of_range& e) {
51725       {
51726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51727       };
51728     } catch (std::exception& e) {
51729       {
51730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51731       };
51732     } catch (Dali::DaliException e) {
51733       {
51734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51735       };
51736     } catch (...) {
51737       {
51738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51739       };
51740     }
51741   }
51742
51743 }
51744
51745
51746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51747   int jresult ;
51748   int result;
51749
51750   result = (int)Dali::Vector< float >::BaseType;
51751   jresult = (int)result;
51752   return jresult;
51753 }
51754
51755
51756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51757   void * jresult ;
51758   Dali::Vector< float > *result = 0 ;
51759
51760   {
51761     try {
51762       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51763     } catch (std::out_of_range& e) {
51764       {
51765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51766       };
51767     } catch (std::exception& e) {
51768       {
51769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51770       };
51771     } catch (Dali::DaliException e) {
51772       {
51773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51774       };
51775     } catch (...) {
51776       {
51777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51778       };
51779     }
51780   }
51781
51782   jresult = (void *)result;
51783   return jresult;
51784 }
51785
51786
51787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51788   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51789
51790   arg1 = (Dali::Vector< float > *)jarg1;
51791   {
51792     try {
51793       delete arg1;
51794     } catch (std::out_of_range& e) {
51795       {
51796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51797       };
51798     } catch (std::exception& e) {
51799       {
51800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51801       };
51802     } catch (Dali::DaliException e) {
51803       {
51804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51805       };
51806     } catch (...) {
51807       {
51808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51809       };
51810     }
51811   }
51812
51813 }
51814
51815
51816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51817   void * jresult ;
51818   Dali::Vector< float > *arg1 = 0 ;
51819   Dali::Vector< float > *result = 0 ;
51820
51821   arg1 = (Dali::Vector< float > *)jarg1;
51822   if (!arg1) {
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 > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
51854   void * jresult ;
51855   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51856   Dali::Vector< float > *arg2 = 0 ;
51857   Dali::Vector< float > *result = 0 ;
51858
51859   arg1 = (Dali::Vector< float > *)jarg1;
51860   arg2 = (Dali::Vector< float > *)jarg2;
51861   if (!arg2) {
51862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51863     return 0;
51864   }
51865   {
51866     try {
51867       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51868     } catch (std::out_of_range& e) {
51869       {
51870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51871       };
51872     } catch (std::exception& e) {
51873       {
51874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51875       };
51876     } catch (Dali::DaliException e) {
51877       {
51878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51879       };
51880     } catch (...) {
51881       {
51882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51883       };
51884     }
51885   }
51886
51887   jresult = (void *)result;
51888   return jresult;
51889 }
51890
51891
51892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51893   void * jresult ;
51894   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51895   Dali::Vector< float >::Iterator result;
51896
51897   arg1 = (Dali::Vector< float > *)jarg1;
51898   {
51899     try {
51900       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51901     } catch (std::out_of_range& e) {
51902       {
51903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51904       };
51905     } catch (std::exception& e) {
51906       {
51907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51908       };
51909     } catch (Dali::DaliException e) {
51910       {
51911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51912       };
51913     } catch (...) {
51914       {
51915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51916       };
51917     }
51918   }
51919
51920   jresult = (void *)result;
51921   return jresult;
51922 }
51923
51924
51925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51926   void * jresult ;
51927   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51928   Dali::Vector< float >::Iterator result;
51929
51930   arg1 = (Dali::Vector< float > *)jarg1;
51931   {
51932     try {
51933       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51934     } catch (std::out_of_range& e) {
51935       {
51936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51937       };
51938     } catch (std::exception& e) {
51939       {
51940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51941       };
51942     } catch (Dali::DaliException e) {
51943       {
51944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51945       };
51946     } catch (...) {
51947       {
51948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51949       };
51950     }
51951   }
51952
51953   jresult = (void *)result;
51954   return jresult;
51955 }
51956
51957
51958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51959   void * jresult ;
51960   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51961   Dali::Vector< float >::SizeType arg2 ;
51962   Dali::Vector< float >::ItemType *result = 0 ;
51963
51964   arg1 = (Dali::Vector< float > *)jarg1;
51965   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51966   {
51967     try {
51968       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51969     } catch (std::out_of_range& e) {
51970       {
51971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51972       };
51973     } catch (std::exception& e) {
51974       {
51975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51976       };
51977     } catch (Dali::DaliException e) {
51978       {
51979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51980       };
51981     } catch (...) {
51982       {
51983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51984       };
51985     }
51986   }
51987
51988   jresult = (void *)result;
51989   return jresult;
51990 }
51991
51992
51993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51994   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51995   Dali::Vector< float >::ItemType *arg2 = 0 ;
51996   Dali::Vector< float >::ItemType temp2 ;
51997
51998   arg1 = (Dali::Vector< float > *)jarg1;
51999   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52000   arg2 = &temp2;
52001   {
52002     try {
52003       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52004     } catch (std::out_of_range& e) {
52005       {
52006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52007       };
52008     } catch (std::exception& e) {
52009       {
52010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52011       };
52012     } catch (Dali::DaliException e) {
52013       {
52014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52015       };
52016     } catch (...) {
52017       {
52018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52019       };
52020     }
52021   }
52022
52023 }
52024
52025
52026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52027   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52028   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52029   Dali::Vector< float >::ItemType *arg3 = 0 ;
52030   Dali::Vector< float >::ItemType temp3 ;
52031
52032   arg1 = (Dali::Vector< float > *)jarg1;
52033   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52034   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52035   arg3 = &temp3;
52036   {
52037     try {
52038       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52039     } catch (std::out_of_range& e) {
52040       {
52041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52042       };
52043     } catch (std::exception& e) {
52044       {
52045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52046       };
52047     } catch (Dali::DaliException e) {
52048       {
52049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52050       };
52051     } catch (...) {
52052       {
52053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52054       };
52055     }
52056   }
52057
52058 }
52059
52060
52061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52062   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52063   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52064   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52065   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52066
52067   arg1 = (Dali::Vector< float > *)jarg1;
52068   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52069   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52070   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52071   {
52072     try {
52073       (arg1)->Insert(arg2,arg3,arg4);
52074     } catch (std::out_of_range& e) {
52075       {
52076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52077       };
52078     } catch (std::exception& e) {
52079       {
52080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52081       };
52082     } catch (Dali::DaliException e) {
52083       {
52084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52085       };
52086     } catch (...) {
52087       {
52088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52089       };
52090     }
52091   }
52092
52093 }
52094
52095
52096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52097   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52098   Dali::Vector< float >::SizeType arg2 ;
52099
52100   arg1 = (Dali::Vector< float > *)jarg1;
52101   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52102   {
52103     try {
52104       (arg1)->Reserve(arg2);
52105     } catch (std::out_of_range& e) {
52106       {
52107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52108       };
52109     } catch (std::exception& e) {
52110       {
52111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52112       };
52113     } catch (Dali::DaliException e) {
52114       {
52115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52116       };
52117     } catch (...) {
52118       {
52119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52120       };
52121     }
52122   }
52123
52124 }
52125
52126 //// ========================= end of part 2 =============================
52127
52128 //// ========================== start part 3 ===============================
52129
52130
52131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52132   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52133   Dali::Vector< float >::SizeType arg2 ;
52134
52135   arg1 = (Dali::Vector< float > *)jarg1;
52136   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52137   {
52138     try {
52139       (arg1)->Resize(arg2);
52140     } catch (std::out_of_range& e) {
52141       {
52142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52143       };
52144     } catch (std::exception& e) {
52145       {
52146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52147       };
52148     } catch (Dali::DaliException e) {
52149       {
52150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52151       };
52152     } catch (...) {
52153       {
52154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52155       };
52156     }
52157   }
52158
52159 }
52160
52161
52162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52163   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52164   Dali::Vector< float >::SizeType arg2 ;
52165   Dali::Vector< float >::ItemType *arg3 = 0 ;
52166   Dali::Vector< float >::ItemType temp3 ;
52167
52168   arg1 = (Dali::Vector< float > *)jarg1;
52169   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52170   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52171   arg3 = &temp3;
52172   {
52173     try {
52174       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52175     } catch (std::out_of_range& e) {
52176       {
52177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52178       };
52179     } catch (std::exception& e) {
52180       {
52181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52182       };
52183     } catch (Dali::DaliException e) {
52184       {
52185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52186       };
52187     } catch (...) {
52188       {
52189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52190       };
52191     }
52192   }
52193
52194 }
52195
52196
52197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52198   void * jresult ;
52199   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52200   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52201   Dali::Vector< float >::Iterator result;
52202
52203   arg1 = (Dali::Vector< float > *)jarg1;
52204   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52205   {
52206     try {
52207       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52208     } catch (std::out_of_range& e) {
52209       {
52210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52211       };
52212     } catch (std::exception& e) {
52213       {
52214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52215       };
52216     } catch (Dali::DaliException e) {
52217       {
52218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52219       };
52220     } catch (...) {
52221       {
52222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52223       };
52224     }
52225   }
52226
52227   jresult = (void *)result;
52228   return jresult;
52229 }
52230
52231
52232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52233   void * jresult ;
52234   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52235   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52236   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52237   Dali::Vector< float >::Iterator result;
52238
52239   arg1 = (Dali::Vector< float > *)jarg1;
52240   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52241   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52242   {
52243     try {
52244       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52245     } catch (std::out_of_range& e) {
52246       {
52247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52248       };
52249     } catch (std::exception& e) {
52250       {
52251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52252       };
52253     } catch (Dali::DaliException e) {
52254       {
52255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52256       };
52257     } catch (...) {
52258       {
52259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52260       };
52261     }
52262   }
52263
52264   jresult = (void *)result;
52265   return jresult;
52266 }
52267
52268
52269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52270   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52271   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52272
52273   arg1 = (Dali::Vector< float > *)jarg1;
52274   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52275   {
52276     try {
52277       (arg1)->Remove(arg2);
52278     } catch (std::out_of_range& e) {
52279       {
52280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52281       };
52282     } catch (std::exception& e) {
52283       {
52284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52285       };
52286     } catch (Dali::DaliException e) {
52287       {
52288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52289       };
52290     } catch (...) {
52291       {
52292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52293       };
52294     }
52295   }
52296
52297 }
52298
52299
52300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52301   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52302   Dali::Vector< float > *arg2 = 0 ;
52303
52304   arg1 = (Dali::Vector< float > *)jarg1;
52305   arg2 = (Dali::Vector< float > *)jarg2;
52306   if (!arg2) {
52307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52308     return ;
52309   }
52310   {
52311     try {
52312       (arg1)->Swap(*arg2);
52313     } catch (std::out_of_range& e) {
52314       {
52315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52316       };
52317     } catch (std::exception& e) {
52318       {
52319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52320       };
52321     } catch (Dali::DaliException e) {
52322       {
52323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52324       };
52325     } catch (...) {
52326       {
52327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52328       };
52329     }
52330   }
52331
52332 }
52333
52334
52335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52336   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52337
52338   arg1 = (Dali::Vector< float > *)jarg1;
52339   {
52340     try {
52341       (arg1)->Clear();
52342     } catch (std::out_of_range& e) {
52343       {
52344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52345       };
52346     } catch (std::exception& e) {
52347       {
52348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52349       };
52350     } catch (Dali::DaliException e) {
52351       {
52352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52353       };
52354     } catch (...) {
52355       {
52356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52357       };
52358     }
52359   }
52360
52361 }
52362
52363
52364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52365   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52366
52367   arg1 = (Dali::Vector< float > *)jarg1;
52368   {
52369     try {
52370       (arg1)->Release();
52371     } catch (std::out_of_range& e) {
52372       {
52373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52374       };
52375     } catch (std::exception& e) {
52376       {
52377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52378       };
52379     } catch (Dali::DaliException e) {
52380       {
52381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52382       };
52383     } catch (...) {
52384       {
52385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52386       };
52387     }
52388   }
52389
52390 }
52391
52392
52393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52394   int jresult ;
52395   int result;
52396
52397   result = (int)Dali::Vector< unsigned char >::BaseType;
52398   jresult = (int)result;
52399   return jresult;
52400 }
52401
52402
52403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52404   void * jresult ;
52405   Dali::Vector< unsigned char > *result = 0 ;
52406
52407   {
52408     try {
52409       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52410     } catch (std::out_of_range& e) {
52411       {
52412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52413       };
52414     } catch (std::exception& e) {
52415       {
52416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52417       };
52418     } catch (Dali::DaliException e) {
52419       {
52420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52421       };
52422     } catch (...) {
52423       {
52424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52425       };
52426     }
52427   }
52428
52429   jresult = (void *)result;
52430   return jresult;
52431 }
52432
52433
52434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52435   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52436
52437   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52438   {
52439     try {
52440       delete arg1;
52441     } catch (std::out_of_range& e) {
52442       {
52443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52444       };
52445     } catch (std::exception& e) {
52446       {
52447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52448       };
52449     } catch (Dali::DaliException e) {
52450       {
52451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52452       };
52453     } catch (...) {
52454       {
52455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52456       };
52457     }
52458   }
52459
52460 }
52461
52462
52463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52464   void * jresult ;
52465   Dali::Vector< unsigned char > *arg1 = 0 ;
52466   Dali::Vector< unsigned char > *result = 0 ;
52467
52468   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52469   if (!arg1) {
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 > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
52501   void * jresult ;
52502   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52503   Dali::Vector< unsigned char > *arg2 = 0 ;
52504   Dali::Vector< unsigned char > *result = 0 ;
52505
52506   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52507   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52508   if (!arg2) {
52509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52510     return 0;
52511   }
52512   {
52513     try {
52514       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52515     } catch (std::out_of_range& e) {
52516       {
52517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52518       };
52519     } catch (std::exception& e) {
52520       {
52521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52522       };
52523     } catch (Dali::DaliException e) {
52524       {
52525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52526       };
52527     } catch (...) {
52528       {
52529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52530       };
52531     }
52532   }
52533
52534   jresult = (void *)result;
52535   return jresult;
52536 }
52537
52538
52539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52540   void * jresult ;
52541   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52542   Dali::Vector< unsigned char >::Iterator result;
52543
52544   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52545   {
52546     try {
52547       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52548     } catch (std::out_of_range& e) {
52549       {
52550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52551       };
52552     } catch (std::exception& e) {
52553       {
52554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52555       };
52556     } catch (Dali::DaliException e) {
52557       {
52558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52559       };
52560     } catch (...) {
52561       {
52562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52563       };
52564     }
52565   }
52566
52567   jresult = (void *)result;
52568   return jresult;
52569 }
52570
52571
52572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52573   void * jresult ;
52574   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52575   Dali::Vector< unsigned char >::Iterator result;
52576
52577   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52578   {
52579     try {
52580       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52581     } catch (std::out_of_range& e) {
52582       {
52583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52584       };
52585     } catch (std::exception& e) {
52586       {
52587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52588       };
52589     } catch (Dali::DaliException e) {
52590       {
52591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52592       };
52593     } catch (...) {
52594       {
52595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52596       };
52597     }
52598   }
52599
52600   jresult = (void *)result;
52601   return jresult;
52602 }
52603
52604
52605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52606   void * jresult ;
52607   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52608   Dali::Vector< unsigned char >::SizeType arg2 ;
52609   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52610
52611   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52612   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52613   {
52614     try {
52615       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52616     } catch (std::out_of_range& e) {
52617       {
52618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52619       };
52620     } catch (std::exception& e) {
52621       {
52622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52623       };
52624     } catch (Dali::DaliException e) {
52625       {
52626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52627       };
52628     } catch (...) {
52629       {
52630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52631       };
52632     }
52633   }
52634
52635   jresult = (void *)result;
52636   return jresult;
52637 }
52638
52639
52640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52641   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52642   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52643   Dali::Vector< unsigned char >::ItemType temp2 ;
52644
52645   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52646   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52647   arg2 = &temp2;
52648   {
52649     try {
52650       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52651     } catch (std::out_of_range& e) {
52652       {
52653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52654       };
52655     } catch (std::exception& e) {
52656       {
52657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52658       };
52659     } catch (Dali::DaliException e) {
52660       {
52661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52662       };
52663     } catch (...) {
52664       {
52665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52666       };
52667     }
52668   }
52669
52670 }
52671
52672
52673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52674   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52675   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52676   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52677   Dali::Vector< unsigned char >::ItemType temp3 ;
52678
52679   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52680   arg2 = jarg2;
52681   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52682   arg3 = &temp3;
52683   {
52684     try {
52685       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52686     } catch (std::out_of_range& e) {
52687       {
52688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52689       };
52690     } catch (std::exception& e) {
52691       {
52692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52693       };
52694     } catch (Dali::DaliException e) {
52695       {
52696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52697       };
52698     } catch (...) {
52699       {
52700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52701       };
52702     }
52703   }
52704
52705
52706
52707 }
52708
52709
52710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52711   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52712   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52713   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52714   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52715
52716   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52717   arg2 = jarg2;
52718   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52719   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52720   {
52721     try {
52722       (arg1)->Insert(arg2,arg3,arg4);
52723     } catch (std::out_of_range& e) {
52724       {
52725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52726       };
52727     } catch (std::exception& e) {
52728       {
52729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52730       };
52731     } catch (Dali::DaliException e) {
52732       {
52733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52734       };
52735     } catch (...) {
52736       {
52737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52738       };
52739     }
52740   }
52741
52742
52743
52744 }
52745
52746
52747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52748   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52749   Dali::Vector< unsigned char >::SizeType arg2 ;
52750
52751   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52752   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52753   {
52754     try {
52755       (arg1)->Reserve(arg2);
52756     } catch (std::out_of_range& e) {
52757       {
52758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52759       };
52760     } catch (std::exception& e) {
52761       {
52762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52763       };
52764     } catch (Dali::DaliException e) {
52765       {
52766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52767       };
52768     } catch (...) {
52769       {
52770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52771       };
52772     }
52773   }
52774
52775 }
52776
52777
52778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52779   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52780   Dali::Vector< unsigned char >::SizeType arg2 ;
52781
52782   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52783   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52784   {
52785     try {
52786       (arg1)->Resize(arg2);
52787     } catch (std::out_of_range& e) {
52788       {
52789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52790       };
52791     } catch (std::exception& e) {
52792       {
52793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52794       };
52795     } catch (Dali::DaliException e) {
52796       {
52797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52798       };
52799     } catch (...) {
52800       {
52801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52802       };
52803     }
52804   }
52805
52806 }
52807
52808
52809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52810   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52811   Dali::Vector< unsigned char >::SizeType arg2 ;
52812   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52813   Dali::Vector< unsigned char >::ItemType temp3 ;
52814
52815   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52816   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52817   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52818   arg3 = &temp3;
52819   {
52820     try {
52821       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52822     } catch (std::out_of_range& e) {
52823       {
52824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52825       };
52826     } catch (std::exception& e) {
52827       {
52828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52829       };
52830     } catch (Dali::DaliException e) {
52831       {
52832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52833       };
52834     } catch (...) {
52835       {
52836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52837       };
52838     }
52839   }
52840
52841 }
52842
52843
52844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52845   void * jresult ;
52846   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52847   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52848   Dali::Vector< unsigned char >::Iterator result;
52849
52850   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52851   arg2 = jarg2;
52852   {
52853     try {
52854       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
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_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52882   void * jresult ;
52883   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52884   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52885   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52886   Dali::Vector< unsigned char >::Iterator result;
52887
52888   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52889   arg2 = jarg2;
52890   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52891   {
52892     try {
52893       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52894     } catch (std::out_of_range& e) {
52895       {
52896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52897       };
52898     } catch (std::exception& e) {
52899       {
52900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52901       };
52902     } catch (Dali::DaliException e) {
52903       {
52904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52905       };
52906     } catch (...) {
52907       {
52908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52909       };
52910     }
52911   }
52912
52913   jresult = (void *)result;
52914
52915
52916   return jresult;
52917 }
52918
52919
52920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52921   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52922   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52923
52924   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52925   arg2 = jarg2;
52926   {
52927     try {
52928       (arg1)->Remove(arg2);
52929     } catch (std::out_of_range& e) {
52930       {
52931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52932       };
52933     } catch (std::exception& e) {
52934       {
52935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52936       };
52937     } catch (Dali::DaliException e) {
52938       {
52939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52940       };
52941     } catch (...) {
52942       {
52943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52944       };
52945     }
52946   }
52947
52948
52949
52950 }
52951
52952
52953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52954   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52955   Dali::Vector< unsigned char > *arg2 = 0 ;
52956
52957   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52958   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52959   if (!arg2) {
52960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52961     return ;
52962   }
52963   {
52964     try {
52965       (arg1)->Swap(*arg2);
52966     } catch (std::out_of_range& e) {
52967       {
52968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52969       };
52970     } catch (std::exception& e) {
52971       {
52972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52973       };
52974     } catch (Dali::DaliException e) {
52975       {
52976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52977       };
52978     } catch (...) {
52979       {
52980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52981       };
52982     }
52983   }
52984
52985 }
52986
52987
52988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52989   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52990
52991   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52992   {
52993     try {
52994       (arg1)->Clear();
52995     } catch (std::out_of_range& e) {
52996       {
52997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52998       };
52999     } catch (std::exception& e) {
53000       {
53001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53002       };
53003     } catch (Dali::DaliException e) {
53004       {
53005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53006       };
53007     } catch (...) {
53008       {
53009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53010       };
53011     }
53012   }
53013
53014 }
53015
53016
53017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53018   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53019
53020   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53021   {
53022     try {
53023       (arg1)->Release();
53024     } catch (std::out_of_range& e) {
53025       {
53026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53027       };
53028     } catch (std::exception& e) {
53029       {
53030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53031       };
53032     } catch (Dali::DaliException e) {
53033       {
53034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53035       };
53036     } catch (...) {
53037       {
53038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53039       };
53040     }
53041   }
53042
53043 }
53044
53045
53046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53047   int jresult ;
53048   int result;
53049
53050   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53051   jresult = (int)result;
53052   return jresult;
53053 }
53054
53055
53056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53057   void * jresult ;
53058   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53059
53060   {
53061     try {
53062       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53063     } catch (std::out_of_range& e) {
53064       {
53065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53066       };
53067     } catch (std::exception& e) {
53068       {
53069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53070       };
53071     } catch (Dali::DaliException e) {
53072       {
53073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53074       };
53075     } catch (...) {
53076       {
53077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53078       };
53079     }
53080   }
53081
53082   jresult = (void *)result;
53083   return jresult;
53084 }
53085
53086
53087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53088   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53089
53090   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53091   {
53092     try {
53093       delete arg1;
53094     } catch (std::out_of_range& e) {
53095       {
53096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53097       };
53098     } catch (std::exception& e) {
53099       {
53100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53101       };
53102     } catch (Dali::DaliException e) {
53103       {
53104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53105       };
53106     } catch (...) {
53107       {
53108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53109       };
53110     }
53111   }
53112
53113 }
53114
53115
53116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53117   void * jresult ;
53118   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53119   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53120
53121   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53122   if (!arg1) {
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 > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
53154   void * jresult ;
53155   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53156   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53157   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53158
53159   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53160   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53161   if (!arg2) {
53162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53163     return 0;
53164   }
53165   {
53166     try {
53167       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53168     } catch (std::out_of_range& e) {
53169       {
53170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53171       };
53172     } catch (std::exception& e) {
53173       {
53174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53175       };
53176     } catch (Dali::DaliException e) {
53177       {
53178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53179       };
53180     } catch (...) {
53181       {
53182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53183       };
53184     }
53185   }
53186
53187   jresult = (void *)result;
53188   return jresult;
53189 }
53190
53191
53192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53193   void * jresult ;
53194   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53195   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53196
53197   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53198   {
53199     try {
53200       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53201     } catch (std::out_of_range& e) {
53202       {
53203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53204       };
53205     } catch (std::exception& e) {
53206       {
53207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53208       };
53209     } catch (Dali::DaliException e) {
53210       {
53211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53212       };
53213     } catch (...) {
53214       {
53215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53216       };
53217     }
53218   }
53219
53220   jresult = (void *)result;
53221   return jresult;
53222 }
53223
53224
53225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53226   void * jresult ;
53227   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53228   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53229
53230   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53231   {
53232     try {
53233       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53234     } catch (std::out_of_range& e) {
53235       {
53236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53237       };
53238     } catch (std::exception& e) {
53239       {
53240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53241       };
53242     } catch (Dali::DaliException e) {
53243       {
53244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53245       };
53246     } catch (...) {
53247       {
53248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53249       };
53250     }
53251   }
53252
53253   jresult = (void *)result;
53254   return jresult;
53255 }
53256
53257
53258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53259   void * jresult ;
53260   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53261   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53262   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53263
53264   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53265   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53266   {
53267     try {
53268       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53269     } catch (std::out_of_range& e) {
53270       {
53271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53272       };
53273     } catch (std::exception& e) {
53274       {
53275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53276       };
53277     } catch (Dali::DaliException e) {
53278       {
53279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53280       };
53281     } catch (...) {
53282       {
53283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53284       };
53285     }
53286   }
53287
53288   jresult = (void *)result;
53289   return jresult;
53290 }
53291
53292
53293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53294   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53295   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53296
53297   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53298   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53299   if (!arg2) {
53300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53301     return ;
53302   }
53303   {
53304     try {
53305       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53306     } catch (std::out_of_range& e) {
53307       {
53308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53309       };
53310     } catch (std::exception& e) {
53311       {
53312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53313       };
53314     } catch (Dali::DaliException e) {
53315       {
53316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53317       };
53318     } catch (...) {
53319       {
53320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53321       };
53322     }
53323   }
53324
53325 }
53326
53327
53328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53329   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53330   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53331   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53332
53333   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53334   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53335   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53336   if (!arg3) {
53337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53338     return ;
53339   }
53340   {
53341     try {
53342       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53343     } catch (std::out_of_range& e) {
53344       {
53345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53346       };
53347     } catch (std::exception& e) {
53348       {
53349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53350       };
53351     } catch (Dali::DaliException e) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53354       };
53355     } catch (...) {
53356       {
53357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53358       };
53359     }
53360   }
53361
53362 }
53363
53364
53365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53366   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53367   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53368   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53369   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53370
53371   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53372   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53373   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53374   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53375   {
53376     try {
53377       (arg1)->Insert(arg2,arg3,arg4);
53378     } catch (std::out_of_range& e) {
53379       {
53380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53381       };
53382     } catch (std::exception& e) {
53383       {
53384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53385       };
53386     } catch (Dali::DaliException e) {
53387       {
53388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53389       };
53390     } catch (...) {
53391       {
53392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53393       };
53394     }
53395   }
53396
53397 }
53398
53399
53400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53401   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53402   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53403
53404   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53405   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53406   {
53407     try {
53408       (arg1)->Reserve(arg2);
53409     } catch (std::out_of_range& e) {
53410       {
53411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53412       };
53413     } catch (std::exception& e) {
53414       {
53415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53416       };
53417     } catch (Dali::DaliException e) {
53418       {
53419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53420       };
53421     } catch (...) {
53422       {
53423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53424       };
53425     }
53426   }
53427
53428 }
53429
53430
53431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53432   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53433   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53434
53435   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53436   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53437   {
53438     try {
53439       (arg1)->Resize(arg2);
53440     } catch (std::out_of_range& e) {
53441       {
53442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53443       };
53444     } catch (std::exception& e) {
53445       {
53446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53447       };
53448     } catch (Dali::DaliException e) {
53449       {
53450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53451       };
53452     } catch (...) {
53453       {
53454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53455       };
53456     }
53457   }
53458
53459 }
53460
53461
53462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53463   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53464   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53465   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53466
53467   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53468   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53469   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53470   if (!arg3) {
53471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53472     return ;
53473   }
53474   {
53475     try {
53476       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53477     } catch (std::out_of_range& e) {
53478       {
53479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53480       };
53481     } catch (std::exception& e) {
53482       {
53483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53484       };
53485     } catch (Dali::DaliException e) {
53486       {
53487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53488       };
53489     } catch (...) {
53490       {
53491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53492       };
53493     }
53494   }
53495
53496 }
53497
53498
53499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53500   void * jresult ;
53501   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53502   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53503   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53504
53505   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53506   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53507   {
53508     try {
53509       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53510     } catch (std::out_of_range& e) {
53511       {
53512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53513       };
53514     } catch (std::exception& e) {
53515       {
53516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53517       };
53518     } catch (Dali::DaliException e) {
53519       {
53520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53521       };
53522     } catch (...) {
53523       {
53524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53525       };
53526     }
53527   }
53528
53529   jresult = (void *)result;
53530   return jresult;
53531 }
53532
53533
53534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53535   void * jresult ;
53536   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53537   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53538   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53539   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53540
53541   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53542   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53543   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53544   {
53545     try {
53546       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53547     } catch (std::out_of_range& e) {
53548       {
53549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53550       };
53551     } catch (std::exception& e) {
53552       {
53553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53554       };
53555     } catch (Dali::DaliException e) {
53556       {
53557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53558       };
53559     } catch (...) {
53560       {
53561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53562       };
53563     }
53564   }
53565
53566   jresult = (void *)result;
53567   return jresult;
53568 }
53569
53570
53571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53572   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53573   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53574
53575   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53576   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53577   {
53578     try {
53579       (arg1)->Remove(arg2);
53580     } catch (std::out_of_range& e) {
53581       {
53582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53583       };
53584     } catch (std::exception& e) {
53585       {
53586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53587       };
53588     } catch (Dali::DaliException e) {
53589       {
53590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53591       };
53592     } catch (...) {
53593       {
53594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53595       };
53596     }
53597   }
53598
53599 }
53600
53601
53602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53603   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53604   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53605
53606   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53607   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53608   if (!arg2) {
53609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53610     return ;
53611   }
53612   {
53613     try {
53614       (arg1)->Swap(*arg2);
53615     } catch (std::out_of_range& e) {
53616       {
53617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53618       };
53619     } catch (std::exception& e) {
53620       {
53621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53622       };
53623     } catch (Dali::DaliException e) {
53624       {
53625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53626       };
53627     } catch (...) {
53628       {
53629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53630       };
53631     }
53632   }
53633
53634 }
53635
53636
53637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53638   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53639
53640   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53641   {
53642     try {
53643       (arg1)->Clear();
53644     } catch (std::out_of_range& e) {
53645       {
53646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53647       };
53648     } catch (std::exception& e) {
53649       {
53650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53651       };
53652     } catch (Dali::DaliException e) {
53653       {
53654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53655       };
53656     } catch (...) {
53657       {
53658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53659       };
53660     }
53661   }
53662
53663 }
53664
53665
53666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53667   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53668
53669   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53670   {
53671     try {
53672       (arg1)->Release();
53673     } catch (std::out_of_range& e) {
53674       {
53675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53676       };
53677     } catch (std::exception& e) {
53678       {
53679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53680       };
53681     } catch (Dali::DaliException e) {
53682       {
53683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53684       };
53685     } catch (...) {
53686       {
53687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53688       };
53689     }
53690   }
53691
53692 }
53693
53694
53695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53696   void * jresult ;
53697   Dali::Signal< void () > *result = 0 ;
53698
53699   {
53700     try {
53701       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53702     } catch (std::out_of_range& e) {
53703       {
53704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53705       };
53706     } catch (std::exception& e) {
53707       {
53708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53709       };
53710     } catch (Dali::DaliException e) {
53711       {
53712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53713       };
53714     } catch (...) {
53715       {
53716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53717       };
53718     }
53719   }
53720
53721   jresult = (void *)result;
53722   return jresult;
53723 }
53724
53725
53726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53727   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53728
53729   arg1 = (Dali::Signal< void () > *)jarg1;
53730   {
53731     try {
53732       delete arg1;
53733     } catch (std::out_of_range& e) {
53734       {
53735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53736       };
53737     } catch (std::exception& e) {
53738       {
53739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53740       };
53741     } catch (Dali::DaliException e) {
53742       {
53743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53744       };
53745     } catch (...) {
53746       {
53747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53748       };
53749     }
53750   }
53751
53752 }
53753
53754
53755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53756   unsigned int jresult ;
53757   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53758   bool result;
53759
53760   arg1 = (Dali::Signal< void () > *)jarg1;
53761   {
53762     try {
53763       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53764     } catch (std::out_of_range& e) {
53765       {
53766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53767       };
53768     } catch (std::exception& e) {
53769       {
53770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53771       };
53772     } catch (Dali::DaliException e) {
53773       {
53774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53775       };
53776     } catch (...) {
53777       {
53778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53779       };
53780     }
53781   }
53782
53783   jresult = result;
53784   return jresult;
53785 }
53786
53787
53788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53789   unsigned long jresult ;
53790   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53791   std::size_t result;
53792
53793   arg1 = (Dali::Signal< void () > *)jarg1;
53794   {
53795     try {
53796       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53797     } catch (std::out_of_range& e) {
53798       {
53799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53800       };
53801     } catch (std::exception& e) {
53802       {
53803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53804       };
53805     } catch (Dali::DaliException e) {
53806       {
53807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53808       };
53809     } catch (...) {
53810       {
53811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53812       };
53813     }
53814   }
53815
53816   jresult = (unsigned long)result;
53817   return jresult;
53818 }
53819
53820
53821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53822   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53823   void (*arg2)() = (void (*)()) 0 ;
53824
53825   arg1 = (Dali::Signal< void () > *)jarg1;
53826   arg2 = (void (*)())jarg2;
53827   {
53828     try {
53829       (arg1)->Connect(arg2);
53830     } catch (std::out_of_range& e) {
53831       {
53832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53833       };
53834     } catch (std::exception& e) {
53835       {
53836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53837       };
53838     } catch (Dali::DaliException e) {
53839       {
53840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53841       };
53842     } catch (...) {
53843       {
53844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53845       };
53846     }
53847   }
53848
53849 }
53850
53851
53852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53853   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53854   void (*arg2)() = (void (*)()) 0 ;
53855
53856   arg1 = (Dali::Signal< void () > *)jarg1;
53857   arg2 = (void (*)())jarg2;
53858   {
53859     try {
53860       (arg1)->Disconnect(arg2);
53861     } catch (std::out_of_range& e) {
53862       {
53863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53864       };
53865     } catch (std::exception& e) {
53866       {
53867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53868       };
53869     } catch (Dali::DaliException e) {
53870       {
53871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53872       };
53873     } catch (...) {
53874       {
53875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53876       };
53877     }
53878   }
53879
53880 }
53881
53882
53883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53884   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53885   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53886   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53887
53888   arg1 = (Dali::Signal< void () > *)jarg1;
53889   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53890   arg3 = (Dali::FunctorDelegate *)jarg3;
53891   {
53892     try {
53893       (arg1)->Connect(arg2,arg3);
53894     } catch (std::out_of_range& e) {
53895       {
53896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53897       };
53898     } catch (std::exception& e) {
53899       {
53900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53901       };
53902     } catch (Dali::DaliException e) {
53903       {
53904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53905       };
53906     } catch (...) {
53907       {
53908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53909       };
53910     }
53911   }
53912
53913 }
53914
53915
53916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53917   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53918
53919   arg1 = (Dali::Signal< void () > *)jarg1;
53920   {
53921     try {
53922       (arg1)->Emit();
53923     } catch (std::out_of_range& e) {
53924       {
53925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53926       };
53927     } catch (std::exception& e) {
53928       {
53929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53930       };
53931     } catch (Dali::DaliException e) {
53932       {
53933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53934       };
53935     } catch (...) {
53936       {
53937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53938       };
53939     }
53940   }
53941
53942 }
53943
53944
53945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53946   unsigned int jresult ;
53947   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53948   bool result;
53949
53950   arg1 = (Dali::Signal< void (float) > *)jarg1;
53951   {
53952     try {
53953       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53954     } catch (std::out_of_range& e) {
53955       {
53956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53957       };
53958     } catch (std::exception& e) {
53959       {
53960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53961       };
53962     } catch (Dali::DaliException e) {
53963       {
53964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53965       };
53966     } catch (...) {
53967       {
53968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53969       };
53970     }
53971   }
53972
53973   jresult = result;
53974   return jresult;
53975 }
53976
53977
53978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53979   unsigned long jresult ;
53980   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53981   std::size_t result;
53982
53983   arg1 = (Dali::Signal< void (float) > *)jarg1;
53984   {
53985     try {
53986       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53987     } catch (std::out_of_range& e) {
53988       {
53989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53990       };
53991     } catch (std::exception& e) {
53992       {
53993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53994       };
53995     } catch (Dali::DaliException e) {
53996       {
53997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53998       };
53999     } catch (...) {
54000       {
54001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54002       };
54003     }
54004   }
54005
54006   jresult = (unsigned long)result;
54007   return jresult;
54008 }
54009
54010
54011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54012   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54013   void (*arg2)(float) = (void (*)(float)) 0 ;
54014
54015   arg1 = (Dali::Signal< void (float) > *)jarg1;
54016   arg2 = (void (*)(float))jarg2;
54017   {
54018     try {
54019       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54020     } catch (std::out_of_range& e) {
54021       {
54022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54023       };
54024     } catch (std::exception& e) {
54025       {
54026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54027       };
54028     } catch (Dali::DaliException e) {
54029       {
54030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54031       };
54032     } catch (...) {
54033       {
54034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54035       };
54036     }
54037   }
54038
54039 }
54040
54041
54042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54043   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54044   void (*arg2)(float) = (void (*)(float)) 0 ;
54045
54046   arg1 = (Dali::Signal< void (float) > *)jarg1;
54047   arg2 = (void (*)(float))jarg2;
54048   {
54049     try {
54050       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54051     } catch (std::out_of_range& e) {
54052       {
54053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54054       };
54055     } catch (std::exception& e) {
54056       {
54057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54058       };
54059     } catch (Dali::DaliException e) {
54060       {
54061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54062       };
54063     } catch (...) {
54064       {
54065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54066       };
54067     }
54068   }
54069
54070 }
54071
54072
54073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54074   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54075   float arg2 ;
54076
54077   arg1 = (Dali::Signal< void (float) > *)jarg1;
54078   arg2 = (float)jarg2;
54079   {
54080     try {
54081       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54082     } catch (std::out_of_range& e) {
54083       {
54084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54085       };
54086     } catch (std::exception& e) {
54087       {
54088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54089       };
54090     } catch (Dali::DaliException e) {
54091       {
54092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54093       };
54094     } catch (...) {
54095       {
54096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54097       };
54098     }
54099   }
54100
54101 }
54102
54103
54104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54105   void * jresult ;
54106   Dali::Signal< void (float) > *result = 0 ;
54107
54108   {
54109     try {
54110       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54111     } catch (std::out_of_range& e) {
54112       {
54113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54114       };
54115     } catch (std::exception& e) {
54116       {
54117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54118       };
54119     } catch (Dali::DaliException e) {
54120       {
54121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54122       };
54123     } catch (...) {
54124       {
54125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54126       };
54127     }
54128   }
54129
54130   jresult = (void *)result;
54131   return jresult;
54132 }
54133
54134
54135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54136   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54137
54138   arg1 = (Dali::Signal< void (float) > *)jarg1;
54139   {
54140     try {
54141       delete arg1;
54142     } catch (std::out_of_range& e) {
54143       {
54144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54145       };
54146     } catch (std::exception& e) {
54147       {
54148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54149       };
54150     } catch (Dali::DaliException e) {
54151       {
54152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54153       };
54154     } catch (...) {
54155       {
54156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54157       };
54158     }
54159   }
54160
54161 }
54162
54163
54164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54165   unsigned int jresult ;
54166   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54167   bool result;
54168
54169   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54170   {
54171     try {
54172       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54173     } catch (std::out_of_range& e) {
54174       {
54175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54176       };
54177     } catch (std::exception& e) {
54178       {
54179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54180       };
54181     } catch (Dali::DaliException e) {
54182       {
54183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54184       };
54185     } catch (...) {
54186       {
54187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54188       };
54189     }
54190   }
54191
54192   jresult = result;
54193   return jresult;
54194 }
54195
54196
54197 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54198   unsigned long jresult ;
54199   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54200   std::size_t result;
54201
54202   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54203   {
54204     try {
54205       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54206     } catch (std::out_of_range& e) {
54207       {
54208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54209       };
54210     } catch (std::exception& e) {
54211       {
54212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54213       };
54214     } catch (Dali::DaliException e) {
54215       {
54216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54217       };
54218     } catch (...) {
54219       {
54220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54221       };
54222     }
54223   }
54224
54225   jresult = (unsigned long)result;
54226   return jresult;
54227 }
54228
54229
54230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54231   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54232   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54233
54234   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54235   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54236   {
54237     try {
54238       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54239     } catch (std::out_of_range& e) {
54240       {
54241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54242       };
54243     } catch (std::exception& e) {
54244       {
54245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54246       };
54247     } catch (Dali::DaliException e) {
54248       {
54249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54250       };
54251     } catch (...) {
54252       {
54253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54254       };
54255     }
54256   }
54257
54258 }
54259
54260
54261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54262   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54263   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54264
54265   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54266   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54267   {
54268     try {
54269       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54270     } catch (std::out_of_range& e) {
54271       {
54272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54273       };
54274     } catch (std::exception& e) {
54275       {
54276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54277       };
54278     } catch (Dali::DaliException e) {
54279       {
54280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54281       };
54282     } catch (...) {
54283       {
54284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54285       };
54286     }
54287   }
54288
54289 }
54290
54291
54292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54293   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54294   Dali::BaseHandle arg2 ;
54295   Dali::BaseHandle *argp2 ;
54296
54297   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54298   argp2 = (Dali::BaseHandle *)jarg2;
54299   if (!argp2) {
54300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54301     return ;
54302   }
54303   arg2 = *argp2;
54304   {
54305     try {
54306       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54307     } catch (std::out_of_range& e) {
54308       {
54309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54310       };
54311     } catch (std::exception& e) {
54312       {
54313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54314       };
54315     } catch (Dali::DaliException e) {
54316       {
54317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54318       };
54319     } catch (...) {
54320       {
54321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54322       };
54323     }
54324   }
54325
54326 }
54327
54328
54329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54330   void * jresult ;
54331   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54332
54333   {
54334     try {
54335       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54336     } catch (std::out_of_range& e) {
54337       {
54338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54339       };
54340     } catch (std::exception& e) {
54341       {
54342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54343       };
54344     } catch (Dali::DaliException e) {
54345       {
54346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54347       };
54348     } catch (...) {
54349       {
54350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54351       };
54352     }
54353   }
54354
54355   jresult = (void *)result;
54356   return jresult;
54357 }
54358
54359
54360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54361   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54362
54363   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54364   {
54365     try {
54366       delete arg1;
54367     } catch (std::out_of_range& e) {
54368       {
54369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54370       };
54371     } catch (std::exception& e) {
54372       {
54373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54374       };
54375     } catch (Dali::DaliException e) {
54376       {
54377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54378       };
54379     } catch (...) {
54380       {
54381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54382       };
54383     }
54384   }
54385
54386 }
54387
54388
54389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54390   unsigned int jresult ;
54391   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54392   bool result;
54393
54394   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54395   {
54396     try {
54397       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54398     } catch (std::out_of_range& e) {
54399       {
54400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54401       };
54402     } catch (std::exception& e) {
54403       {
54404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54405       };
54406     } catch (Dali::DaliException e) {
54407       {
54408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54409       };
54410     } catch (...) {
54411       {
54412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54413       };
54414     }
54415   }
54416
54417   jresult = result;
54418   return jresult;
54419 }
54420
54421
54422 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54423   unsigned long jresult ;
54424   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54425   std::size_t result;
54426
54427   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54428   {
54429     try {
54430       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54431     } catch (std::out_of_range& e) {
54432       {
54433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54434       };
54435     } catch (std::exception& e) {
54436       {
54437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54438       };
54439     } catch (Dali::DaliException e) {
54440       {
54441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54442       };
54443     } catch (...) {
54444       {
54445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54446       };
54447     }
54448   }
54449
54450   jresult = (unsigned long)result;
54451   return jresult;
54452 }
54453
54454
54455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54456   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54457   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54458
54459   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54460   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54461   {
54462     try {
54463       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54464     } catch (std::out_of_range& e) {
54465       {
54466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54467       };
54468     } catch (std::exception& e) {
54469       {
54470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54471       };
54472     } catch (Dali::DaliException e) {
54473       {
54474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54475       };
54476     } catch (...) {
54477       {
54478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54479       };
54480     }
54481   }
54482
54483 }
54484
54485
54486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54487   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54488   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54489
54490   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54491   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54492   {
54493     try {
54494       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54495     } catch (std::out_of_range& e) {
54496       {
54497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54498       };
54499     } catch (std::exception& e) {
54500       {
54501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54502       };
54503     } catch (Dali::DaliException e) {
54504       {
54505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54506       };
54507     } catch (...) {
54508       {
54509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54510       };
54511     }
54512   }
54513
54514 }
54515
54516
54517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54518   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54519   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54520
54521   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54522   arg2 = (Dali::RefObject *)jarg2;
54523   {
54524     try {
54525       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54526     } catch (std::out_of_range& e) {
54527       {
54528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54529       };
54530     } catch (std::exception& e) {
54531       {
54532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54533       };
54534     } catch (Dali::DaliException e) {
54535       {
54536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54537       };
54538     } catch (...) {
54539       {
54540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54541       };
54542     }
54543   }
54544
54545 }
54546
54547
54548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54549   void * jresult ;
54550   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54551
54552   {
54553     try {
54554       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54555     } catch (std::out_of_range& e) {
54556       {
54557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54558       };
54559     } catch (std::exception& e) {
54560       {
54561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54562       };
54563     } catch (Dali::DaliException e) {
54564       {
54565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54566       };
54567     } catch (...) {
54568       {
54569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54570       };
54571     }
54572   }
54573
54574   jresult = (void *)result;
54575   return jresult;
54576 }
54577
54578
54579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54580   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54581
54582   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54583   {
54584     try {
54585       delete arg1;
54586     } catch (std::out_of_range& e) {
54587       {
54588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54589       };
54590     } catch (std::exception& e) {
54591       {
54592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54593       };
54594     } catch (Dali::DaliException e) {
54595       {
54596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54597       };
54598     } catch (...) {
54599       {
54600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54601       };
54602     }
54603   }
54604
54605 }
54606
54607
54608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54609   unsigned int jresult ;
54610   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54611   bool result;
54612
54613   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54614   {
54615     try {
54616       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54617     } catch (std::out_of_range& e) {
54618       {
54619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54620       };
54621     } catch (std::exception& e) {
54622       {
54623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54624       };
54625     } catch (Dali::DaliException e) {
54626       {
54627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54628       };
54629     } catch (...) {
54630       {
54631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54632       };
54633     }
54634   }
54635
54636   jresult = result;
54637   return jresult;
54638 }
54639
54640
54641 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54642   unsigned long jresult ;
54643   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54644   std::size_t result;
54645
54646   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54647   {
54648     try {
54649       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54650     } catch (std::out_of_range& e) {
54651       {
54652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54653       };
54654     } catch (std::exception& e) {
54655       {
54656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54657       };
54658     } catch (Dali::DaliException e) {
54659       {
54660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54661       };
54662     } catch (...) {
54663       {
54664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54665       };
54666     }
54667   }
54668
54669   jresult = (unsigned long)result;
54670   return jresult;
54671 }
54672
54673
54674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54675   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54676   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54677
54678   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54679   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54680   {
54681     try {
54682       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54683     } catch (std::out_of_range& e) {
54684       {
54685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54686       };
54687     } catch (std::exception& e) {
54688       {
54689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54690       };
54691     } catch (Dali::DaliException e) {
54692       {
54693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54694       };
54695     } catch (...) {
54696       {
54697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54698       };
54699     }
54700   }
54701
54702 }
54703
54704
54705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54706   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54707   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54708
54709   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54710   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54711   {
54712     try {
54713       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54714     } catch (std::out_of_range& e) {
54715       {
54716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54717       };
54718     } catch (std::exception& e) {
54719       {
54720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54721       };
54722     } catch (Dali::DaliException e) {
54723       {
54724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54725       };
54726     } catch (...) {
54727       {
54728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54729       };
54730     }
54731   }
54732
54733 }
54734
54735
54736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54737   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54738   Dali::PropertyNotification *arg2 = 0 ;
54739
54740   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54741   arg2 = (Dali::PropertyNotification *)jarg2;
54742   if (!arg2) {
54743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54744     return ;
54745   }
54746   {
54747     try {
54748       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54749     } catch (std::out_of_range& e) {
54750       {
54751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54752       };
54753     } catch (std::exception& e) {
54754       {
54755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54756       };
54757     } catch (Dali::DaliException e) {
54758       {
54759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54760       };
54761     } catch (...) {
54762       {
54763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54764       };
54765     }
54766   }
54767
54768 }
54769
54770
54771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54772   void * jresult ;
54773   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54774
54775   {
54776     try {
54777       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54778     } catch (std::out_of_range& e) {
54779       {
54780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54781       };
54782     } catch (std::exception& e) {
54783       {
54784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54785       };
54786     } catch (Dali::DaliException e) {
54787       {
54788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54789       };
54790     } catch (...) {
54791       {
54792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54793       };
54794     }
54795   }
54796
54797   jresult = (void *)result;
54798   return jresult;
54799 }
54800
54801
54802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54803   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54804
54805   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54806   {
54807     try {
54808       delete arg1;
54809     } catch (std::out_of_range& e) {
54810       {
54811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54812       };
54813     } catch (std::exception& e) {
54814       {
54815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54816       };
54817     } catch (Dali::DaliException e) {
54818       {
54819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54820       };
54821     } catch (...) {
54822       {
54823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54824       };
54825     }
54826   }
54827
54828 }
54829
54830
54831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54832   unsigned int jresult ;
54833   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54834   bool result;
54835
54836   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54837   {
54838     try {
54839       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54840     } catch (std::out_of_range& e) {
54841       {
54842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54843       };
54844     } catch (std::exception& e) {
54845       {
54846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54847       };
54848     } catch (Dali::DaliException e) {
54849       {
54850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54851       };
54852     } catch (...) {
54853       {
54854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54855       };
54856     }
54857   }
54858
54859   jresult = result;
54860   return jresult;
54861 }
54862
54863
54864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54865   unsigned long jresult ;
54866   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54867   std::size_t result;
54868
54869   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54870   {
54871     try {
54872       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54873     } catch (std::out_of_range& e) {
54874       {
54875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54876       };
54877     } catch (std::exception& e) {
54878       {
54879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54880       };
54881     } catch (Dali::DaliException e) {
54882       {
54883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54884       };
54885     } catch (...) {
54886       {
54887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54888       };
54889     }
54890   }
54891
54892   jresult = (unsigned long)result;
54893   return jresult;
54894 }
54895
54896
54897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54898   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54899   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54900
54901   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54902   arg2 = (void (*)(Dali::Image))jarg2;
54903   {
54904     try {
54905       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54906     } catch (std::out_of_range& e) {
54907       {
54908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54909       };
54910     } catch (std::exception& e) {
54911       {
54912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54913       };
54914     } catch (Dali::DaliException e) {
54915       {
54916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54917       };
54918     } catch (...) {
54919       {
54920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54921       };
54922     }
54923   }
54924
54925 }
54926
54927
54928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54929   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54930   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54931
54932   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54933   arg2 = (void (*)(Dali::Image))jarg2;
54934   {
54935     try {
54936       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54937     } catch (std::out_of_range& e) {
54938       {
54939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54940       };
54941     } catch (std::exception& e) {
54942       {
54943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54944       };
54945     } catch (Dali::DaliException e) {
54946       {
54947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54948       };
54949     } catch (...) {
54950       {
54951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54952       };
54953     }
54954   }
54955
54956 }
54957
54958
54959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54960   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54961   Dali::Image arg2 ;
54962   Dali::Image *argp2 ;
54963
54964   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54965   argp2 = (Dali::Image *)jarg2;
54966   if (!argp2) {
54967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54968     return ;
54969   }
54970   arg2 = *argp2;
54971   {
54972     try {
54973       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54974     } catch (std::out_of_range& e) {
54975       {
54976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54977       };
54978     } catch (std::exception& e) {
54979       {
54980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54981       };
54982     } catch (Dali::DaliException e) {
54983       {
54984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54985       };
54986     } catch (...) {
54987       {
54988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54989       };
54990     }
54991   }
54992
54993 }
54994
54995
54996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54997   void * jresult ;
54998   Dali::Signal< void (Dali::Image) > *result = 0 ;
54999
55000   {
55001     try {
55002       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55003     } catch (std::out_of_range& e) {
55004       {
55005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55006       };
55007     } catch (std::exception& e) {
55008       {
55009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55010       };
55011     } catch (Dali::DaliException e) {
55012       {
55013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55014       };
55015     } catch (...) {
55016       {
55017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55018       };
55019     }
55020   }
55021
55022   jresult = (void *)result;
55023   return jresult;
55024 }
55025
55026
55027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55028   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55029
55030   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55031   {
55032     try {
55033       delete arg1;
55034     } catch (std::out_of_range& e) {
55035       {
55036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55037       };
55038     } catch (std::exception& e) {
55039       {
55040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55041       };
55042     } catch (Dali::DaliException e) {
55043       {
55044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55045       };
55046     } catch (...) {
55047       {
55048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55049       };
55050     }
55051   }
55052
55053 }
55054
55055
55056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55057   void * jresult ;
55058   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55059
55060   {
55061     try {
55062       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55063     } catch (std::out_of_range& e) {
55064       {
55065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55066       };
55067     } catch (std::exception& e) {
55068       {
55069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55070       };
55071     } catch (Dali::DaliException e) {
55072       {
55073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55074       };
55075     } catch (...) {
55076       {
55077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55078       };
55079     }
55080   }
55081
55082   jresult = (void *)result;
55083   return jresult;
55084 }
55085
55086
55087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55088   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55089
55090   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55091   {
55092     try {
55093       delete arg1;
55094     } catch (std::out_of_range& e) {
55095       {
55096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55097       };
55098     } catch (std::exception& e) {
55099       {
55100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55101       };
55102     } catch (Dali::DaliException e) {
55103       {
55104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55105       };
55106     } catch (...) {
55107       {
55108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55109       };
55110     }
55111   }
55112
55113 }
55114
55115
55116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55117   unsigned int jresult ;
55118   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55119   bool result;
55120
55121   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55122   {
55123     try {
55124       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);
55125     } catch (std::out_of_range& e) {
55126       {
55127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55128       };
55129     } catch (std::exception& e) {
55130       {
55131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55132       };
55133     } catch (Dali::DaliException e) {
55134       {
55135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55136       };
55137     } catch (...) {
55138       {
55139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55140       };
55141     }
55142   }
55143
55144   jresult = result;
55145   return jresult;
55146 }
55147
55148
55149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55150   unsigned long jresult ;
55151   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55152   std::size_t result;
55153
55154   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55155   {
55156     try {
55157       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);
55158     } catch (std::out_of_range& e) {
55159       {
55160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55161       };
55162     } catch (std::exception& e) {
55163       {
55164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55165       };
55166     } catch (Dali::DaliException e) {
55167       {
55168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55169       };
55170     } catch (...) {
55171       {
55172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55173       };
55174     }
55175   }
55176
55177   jresult = (unsigned long)result;
55178   return jresult;
55179 }
55180
55181
55182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55183   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55184   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55185
55186   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55187   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55188   {
55189     try {
55190       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55191     } catch (std::out_of_range& e) {
55192       {
55193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55194       };
55195     } catch (std::exception& e) {
55196       {
55197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55198       };
55199     } catch (Dali::DaliException e) {
55200       {
55201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55202       };
55203     } catch (...) {
55204       {
55205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55206       };
55207     }
55208   }
55209
55210 }
55211
55212
55213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55214   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55215   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55216
55217   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55218   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55219   {
55220     try {
55221       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55222     } catch (std::out_of_range& e) {
55223       {
55224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55225       };
55226     } catch (std::exception& e) {
55227       {
55228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55229       };
55230     } catch (Dali::DaliException e) {
55231       {
55232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55233       };
55234     } catch (...) {
55235       {
55236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55237       };
55238     }
55239   }
55240
55241 }
55242
55243
55244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55245   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55246   Dali::Actor arg2 ;
55247   Dali::LongPressGesture *arg3 = 0 ;
55248   Dali::Actor *argp2 ;
55249
55250   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55251   argp2 = (Dali::Actor *)jarg2;
55252   if (!argp2) {
55253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55254     return ;
55255   }
55256   arg2 = *argp2;
55257   arg3 = (Dali::LongPressGesture *)jarg3;
55258   if (!arg3) {
55259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55260     return ;
55261   }
55262   {
55263     try {
55264       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55265     } catch (std::out_of_range& e) {
55266       {
55267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55268       };
55269     } catch (std::exception& e) {
55270       {
55271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55272       };
55273     } catch (Dali::DaliException e) {
55274       {
55275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55276       };
55277     } catch (...) {
55278       {
55279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55280       };
55281     }
55282   }
55283
55284 }
55285
55286
55287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55288   void * jresult ;
55289   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55290
55291   {
55292     try {
55293       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55294     } catch (std::out_of_range& e) {
55295       {
55296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55297       };
55298     } catch (std::exception& e) {
55299       {
55300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55301       };
55302     } catch (Dali::DaliException e) {
55303       {
55304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55305       };
55306     } catch (...) {
55307       {
55308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55309       };
55310     }
55311   }
55312
55313   jresult = (void *)result;
55314   return jresult;
55315 }
55316
55317
55318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55319   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55320
55321   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55322   {
55323     try {
55324       delete arg1;
55325     } catch (std::out_of_range& e) {
55326       {
55327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55328       };
55329     } catch (std::exception& e) {
55330       {
55331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55332       };
55333     } catch (Dali::DaliException e) {
55334       {
55335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55336       };
55337     } catch (...) {
55338       {
55339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55340       };
55341     }
55342   }
55343
55344 }
55345
55346
55347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55348   unsigned int jresult ;
55349   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55350   bool result;
55351
55352   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55353   {
55354     try {
55355       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);
55356     } catch (std::out_of_range& e) {
55357       {
55358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55359       };
55360     } catch (std::exception& e) {
55361       {
55362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55363       };
55364     } catch (Dali::DaliException e) {
55365       {
55366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55367       };
55368     } catch (...) {
55369       {
55370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55371       };
55372     }
55373   }
55374
55375   jresult = result;
55376   return jresult;
55377 }
55378
55379
55380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55381   unsigned long jresult ;
55382   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55383   std::size_t result;
55384
55385   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55386   {
55387     try {
55388       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);
55389     } catch (std::out_of_range& e) {
55390       {
55391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55392       };
55393     } catch (std::exception& e) {
55394       {
55395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55396       };
55397     } catch (Dali::DaliException e) {
55398       {
55399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55400       };
55401     } catch (...) {
55402       {
55403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55404       };
55405     }
55406   }
55407
55408   jresult = (unsigned long)result;
55409   return jresult;
55410 }
55411
55412
55413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55414   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55415   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55416
55417   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55418   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55419   {
55420     try {
55421       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55422     } catch (std::out_of_range& e) {
55423       {
55424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55425       };
55426     } catch (std::exception& e) {
55427       {
55428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55429       };
55430     } catch (Dali::DaliException e) {
55431       {
55432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55433       };
55434     } catch (...) {
55435       {
55436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55437       };
55438     }
55439   }
55440
55441 }
55442
55443
55444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55445   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55446   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55447
55448   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55449   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55450   {
55451     try {
55452       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55453     } catch (std::out_of_range& e) {
55454       {
55455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55456       };
55457     } catch (std::exception& e) {
55458       {
55459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55460       };
55461     } catch (Dali::DaliException e) {
55462       {
55463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55464       };
55465     } catch (...) {
55466       {
55467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55468       };
55469     }
55470   }
55471
55472 }
55473
55474
55475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55476   unsigned int jresult ;
55477   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55478   Dali::Actor arg2 ;
55479   Dali::TouchData *arg3 = 0 ;
55480   Dali::Actor *argp2 ;
55481   bool result;
55482
55483   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55484   argp2 = (Dali::Actor *)jarg2;
55485   if (!argp2) {
55486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55487     return 0;
55488   }
55489   arg2 = *argp2;
55490   arg3 = (Dali::TouchData *)jarg3;
55491   if (!arg3) {
55492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55493     return 0;
55494   }
55495   {
55496     try {
55497       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55498     } catch (std::out_of_range& e) {
55499       {
55500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55501       };
55502     } catch (std::exception& e) {
55503       {
55504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55505       };
55506     } catch (Dali::DaliException e) {
55507       {
55508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55509       };
55510     } catch (...) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55513       };
55514     }
55515   }
55516
55517   jresult = result;
55518   return jresult;
55519 }
55520
55521
55522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55523   void * jresult ;
55524   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55525
55526   {
55527     try {
55528       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55529     } catch (std::out_of_range& e) {
55530       {
55531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55532       };
55533     } catch (std::exception& e) {
55534       {
55535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55536       };
55537     } catch (Dali::DaliException e) {
55538       {
55539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55540       };
55541     } catch (...) {
55542       {
55543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55544       };
55545     }
55546   }
55547
55548   jresult = (void *)result;
55549   return jresult;
55550 }
55551
55552
55553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55554   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55555
55556   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55557   {
55558     try {
55559       delete arg1;
55560     } catch (std::out_of_range& e) {
55561       {
55562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55563       };
55564     } catch (std::exception& e) {
55565       {
55566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55567       };
55568     } catch (Dali::DaliException e) {
55569       {
55570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55571       };
55572     } catch (...) {
55573       {
55574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55575       };
55576     }
55577   }
55578
55579 }
55580
55581
55582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55583   unsigned int jresult ;
55584   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55585   bool result;
55586
55587   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55588   {
55589     try {
55590       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);
55591     } catch (std::out_of_range& e) {
55592       {
55593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55594       };
55595     } catch (std::exception& e) {
55596       {
55597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55598       };
55599     } catch (Dali::DaliException e) {
55600       {
55601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55602       };
55603     } catch (...) {
55604       {
55605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55606       };
55607     }
55608   }
55609
55610   jresult = result;
55611   return jresult;
55612 }
55613
55614
55615 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55616   unsigned long jresult ;
55617   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55618   std::size_t result;
55619
55620   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55621   {
55622     try {
55623       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);
55624     } catch (std::out_of_range& e) {
55625       {
55626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55627       };
55628     } catch (std::exception& e) {
55629       {
55630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55631       };
55632     } catch (Dali::DaliException e) {
55633       {
55634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55635       };
55636     } catch (...) {
55637       {
55638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55639       };
55640     }
55641   }
55642
55643   jresult = (unsigned long)result;
55644   return jresult;
55645 }
55646
55647
55648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55649   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55650   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55651
55652   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55653   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55654   {
55655     try {
55656       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55657     } catch (std::out_of_range& e) {
55658       {
55659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55660       };
55661     } catch (std::exception& e) {
55662       {
55663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55664       };
55665     } catch (Dali::DaliException e) {
55666       {
55667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55668       };
55669     } catch (...) {
55670       {
55671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55672       };
55673     }
55674   }
55675
55676 }
55677
55678
55679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55680   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55681   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55682
55683   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55684   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55685   {
55686     try {
55687       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55688     } catch (std::out_of_range& e) {
55689       {
55690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55691       };
55692     } catch (std::exception& e) {
55693       {
55694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55695       };
55696     } catch (Dali::DaliException e) {
55697       {
55698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55699       };
55700     } catch (...) {
55701       {
55702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55703       };
55704     }
55705   }
55706
55707 }
55708
55709
55710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55711   unsigned int jresult ;
55712   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55713   Dali::Actor arg2 ;
55714   Dali::HoverEvent *arg3 = 0 ;
55715   Dali::Actor *argp2 ;
55716   bool result;
55717
55718   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55719   argp2 = (Dali::Actor *)jarg2;
55720   if (!argp2) {
55721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55722     return 0;
55723   }
55724   arg2 = *argp2;
55725   arg3 = (Dali::HoverEvent *)jarg3;
55726   if (!arg3) {
55727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55728     return 0;
55729   }
55730   {
55731     try {
55732       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55733     } catch (std::out_of_range& e) {
55734       {
55735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55736       };
55737     } catch (std::exception& e) {
55738       {
55739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55740       };
55741     } catch (Dali::DaliException e) {
55742       {
55743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55744       };
55745     } catch (...) {
55746       {
55747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55748       };
55749     }
55750   }
55751
55752   jresult = result;
55753   return jresult;
55754 }
55755
55756
55757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55758   void * jresult ;
55759   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55760
55761   {
55762     try {
55763       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55764     } catch (std::out_of_range& e) {
55765       {
55766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55767       };
55768     } catch (std::exception& e) {
55769       {
55770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55771       };
55772     } catch (Dali::DaliException e) {
55773       {
55774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55775       };
55776     } catch (...) {
55777       {
55778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55779       };
55780     }
55781   }
55782
55783   jresult = (void *)result;
55784   return jresult;
55785 }
55786
55787
55788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55789   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55790
55791   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55792   {
55793     try {
55794       delete arg1;
55795     } catch (std::out_of_range& e) {
55796       {
55797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55798       };
55799     } catch (std::exception& e) {
55800       {
55801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55802       };
55803     } catch (Dali::DaliException e) {
55804       {
55805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55806       };
55807     } catch (...) {
55808       {
55809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55810       };
55811     }
55812   }
55813
55814 }
55815
55816
55817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55818   unsigned int jresult ;
55819   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55820   bool result;
55821
55822   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55823   {
55824     try {
55825       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);
55826     } catch (std::out_of_range& e) {
55827       {
55828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55829       };
55830     } catch (std::exception& e) {
55831       {
55832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55833       };
55834     } catch (Dali::DaliException e) {
55835       {
55836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55837       };
55838     } catch (...) {
55839       {
55840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55841       };
55842     }
55843   }
55844
55845   jresult = result;
55846   return jresult;
55847 }
55848
55849
55850 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55851   unsigned long jresult ;
55852   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55853   std::size_t result;
55854
55855   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55856   {
55857     try {
55858       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);
55859     } catch (std::out_of_range& e) {
55860       {
55861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55862       };
55863     } catch (std::exception& e) {
55864       {
55865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55866       };
55867     } catch (Dali::DaliException e) {
55868       {
55869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55870       };
55871     } catch (...) {
55872       {
55873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55874       };
55875     }
55876   }
55877
55878   jresult = (unsigned long)result;
55879   return jresult;
55880 }
55881
55882
55883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55884   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55885   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55886
55887   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55888   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55889   {
55890     try {
55891       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55892     } catch (std::out_of_range& e) {
55893       {
55894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55895       };
55896     } catch (std::exception& e) {
55897       {
55898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55899       };
55900     } catch (Dali::DaliException e) {
55901       {
55902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55903       };
55904     } catch (...) {
55905       {
55906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55907       };
55908     }
55909   }
55910
55911 }
55912
55913
55914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55915   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55916   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55917
55918   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55919   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55920   {
55921     try {
55922       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55923     } catch (std::out_of_range& e) {
55924       {
55925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55926       };
55927     } catch (std::exception& e) {
55928       {
55929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55930       };
55931     } catch (Dali::DaliException e) {
55932       {
55933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55934       };
55935     } catch (...) {
55936       {
55937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55938       };
55939     }
55940   }
55941
55942 }
55943
55944
55945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55946   unsigned int jresult ;
55947   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55948   Dali::Actor arg2 ;
55949   Dali::WheelEvent *arg3 = 0 ;
55950   Dali::Actor *argp2 ;
55951   bool result;
55952
55953   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55954   argp2 = (Dali::Actor *)jarg2;
55955   if (!argp2) {
55956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55957     return 0;
55958   }
55959   arg2 = *argp2;
55960   arg3 = (Dali::WheelEvent *)jarg3;
55961   if (!arg3) {
55962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55963     return 0;
55964   }
55965   {
55966     try {
55967       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55968     } catch (std::out_of_range& e) {
55969       {
55970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55971       };
55972     } catch (std::exception& e) {
55973       {
55974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55975       };
55976     } catch (Dali::DaliException e) {
55977       {
55978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55979       };
55980     } catch (...) {
55981       {
55982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55983       };
55984     }
55985   }
55986
55987   jresult = result;
55988   return jresult;
55989 }
55990
55991
55992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55993   void * jresult ;
55994   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55995
55996   {
55997     try {
55998       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55999     } catch (std::out_of_range& e) {
56000       {
56001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56002       };
56003     } catch (std::exception& e) {
56004       {
56005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56006       };
56007     } catch (Dali::DaliException e) {
56008       {
56009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56010       };
56011     } catch (...) {
56012       {
56013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56014       };
56015     }
56016   }
56017
56018   jresult = (void *)result;
56019   return jresult;
56020 }
56021
56022
56023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56024   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56025
56026   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56027   {
56028     try {
56029       delete arg1;
56030     } catch (std::out_of_range& e) {
56031       {
56032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56033       };
56034     } catch (std::exception& e) {
56035       {
56036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56037       };
56038     } catch (Dali::DaliException e) {
56039       {
56040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56041       };
56042     } catch (...) {
56043       {
56044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56045       };
56046     }
56047   }
56048
56049 }
56050
56051
56052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56053   unsigned int jresult ;
56054   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56055   bool result;
56056
56057   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56058   {
56059     try {
56060       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56061     } catch (std::out_of_range& e) {
56062       {
56063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56064       };
56065     } catch (std::exception& e) {
56066       {
56067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56068       };
56069     } catch (Dali::DaliException e) {
56070       {
56071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56072       };
56073     } catch (...) {
56074       {
56075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56076       };
56077     }
56078   }
56079
56080   jresult = result;
56081   return jresult;
56082 }
56083
56084
56085 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56086   unsigned long jresult ;
56087   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56088   std::size_t result;
56089
56090   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56091   {
56092     try {
56093       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56094     } catch (std::out_of_range& e) {
56095       {
56096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56097       };
56098     } catch (std::exception& e) {
56099       {
56100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56101       };
56102     } catch (Dali::DaliException e) {
56103       {
56104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56105       };
56106     } catch (...) {
56107       {
56108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56109       };
56110     }
56111   }
56112
56113   jresult = (unsigned long)result;
56114   return jresult;
56115 }
56116
56117
56118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56119   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56120   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56121
56122   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56123   arg2 = (void (*)(Dali::Actor))jarg2;
56124   {
56125     try {
56126       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56127     } catch (std::out_of_range& e) {
56128       {
56129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56130       };
56131     } catch (std::exception& e) {
56132       {
56133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56134       };
56135     } catch (Dali::DaliException e) {
56136       {
56137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56138       };
56139     } catch (...) {
56140       {
56141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56142       };
56143     }
56144   }
56145
56146 }
56147
56148
56149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56150   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56151   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56152
56153   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56154   arg2 = (void (*)(Dali::Actor))jarg2;
56155   {
56156     try {
56157       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56158     } catch (std::out_of_range& e) {
56159       {
56160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56161       };
56162     } catch (std::exception& e) {
56163       {
56164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56165       };
56166     } catch (Dali::DaliException e) {
56167       {
56168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56169       };
56170     } catch (...) {
56171       {
56172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56173       };
56174     }
56175   }
56176
56177 }
56178
56179
56180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56181   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56182   Dali::Actor arg2 ;
56183   Dali::Actor *argp2 ;
56184
56185   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56186   argp2 = (Dali::Actor *)jarg2;
56187   if (!argp2) {
56188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56189     return ;
56190   }
56191   arg2 = *argp2;
56192   {
56193     try {
56194       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56195     } catch (std::out_of_range& e) {
56196       {
56197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56198       };
56199     } catch (std::exception& e) {
56200       {
56201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56202       };
56203     } catch (Dali::DaliException e) {
56204       {
56205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56206       };
56207     } catch (...) {
56208       {
56209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56210       };
56211     }
56212   }
56213
56214 }
56215
56216
56217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56218   void * jresult ;
56219   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56220
56221   {
56222     try {
56223       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56224     } catch (std::out_of_range& e) {
56225       {
56226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56227       };
56228     } catch (std::exception& e) {
56229       {
56230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56231       };
56232     } catch (Dali::DaliException e) {
56233       {
56234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56235       };
56236     } catch (...) {
56237       {
56238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56239       };
56240     }
56241   }
56242
56243   jresult = (void *)result;
56244   return jresult;
56245 }
56246
56247
56248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56249   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56250
56251   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56252   {
56253     try {
56254       delete arg1;
56255     } catch (std::out_of_range& e) {
56256       {
56257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56258       };
56259     } catch (std::exception& e) {
56260       {
56261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56262       };
56263     } catch (Dali::DaliException e) {
56264       {
56265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56266       };
56267     } catch (...) {
56268       {
56269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56270       };
56271     }
56272   }
56273
56274 }
56275
56276
56277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56278   unsigned int jresult ;
56279   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56280   bool result;
56281
56282   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56283   {
56284     try {
56285       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56286     } catch (std::out_of_range& e) {
56287       {
56288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56289       };
56290     } catch (std::exception& e) {
56291       {
56292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56293       };
56294     } catch (Dali::DaliException e) {
56295       {
56296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56297       };
56298     } catch (...) {
56299       {
56300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56301       };
56302     }
56303   }
56304
56305   jresult = result;
56306   return jresult;
56307 }
56308
56309
56310 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56311   unsigned long jresult ;
56312   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56313   std::size_t result;
56314
56315   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56316   {
56317     try {
56318       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56319     } catch (std::out_of_range& e) {
56320       {
56321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56322       };
56323     } catch (std::exception& e) {
56324       {
56325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56326       };
56327     } catch (Dali::DaliException e) {
56328       {
56329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56330       };
56331     } catch (...) {
56332       {
56333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56334       };
56335     }
56336   }
56337
56338   jresult = (unsigned long)result;
56339   return jresult;
56340 }
56341
56342
56343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56344   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56345   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56346
56347   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56348   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56349   {
56350     try {
56351       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56352     } catch (std::out_of_range& e) {
56353       {
56354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56355       };
56356     } catch (std::exception& e) {
56357       {
56358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56359       };
56360     } catch (Dali::DaliException e) {
56361       {
56362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56363       };
56364     } catch (...) {
56365       {
56366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56367       };
56368     }
56369   }
56370
56371 }
56372
56373
56374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56375   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56376   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56377
56378   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56379   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56380   {
56381     try {
56382       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56383     } catch (std::out_of_range& e) {
56384       {
56385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56386       };
56387     } catch (std::exception& e) {
56388       {
56389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56390       };
56391     } catch (Dali::DaliException e) {
56392       {
56393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56394       };
56395     } catch (...) {
56396       {
56397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56398       };
56399     }
56400   }
56401
56402 }
56403
56404
56405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56406   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56407   Dali::KeyEvent *arg2 = 0 ;
56408
56409   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56410   arg2 = (Dali::KeyEvent *)jarg2;
56411   if (!arg2) {
56412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56413     return ;
56414   }
56415   {
56416     try {
56417       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56418     } catch (std::out_of_range& e) {
56419       {
56420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56421       };
56422     } catch (std::exception& e) {
56423       {
56424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56425       };
56426     } catch (Dali::DaliException e) {
56427       {
56428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56429       };
56430     } catch (...) {
56431       {
56432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56433       };
56434     }
56435   }
56436
56437 }
56438
56439
56440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56441   void * jresult ;
56442   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56443
56444   {
56445     try {
56446       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56447     } catch (std::out_of_range& e) {
56448       {
56449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56450       };
56451     } catch (std::exception& e) {
56452       {
56453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56454       };
56455     } catch (Dali::DaliException e) {
56456       {
56457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56458       };
56459     } catch (...) {
56460       {
56461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56462       };
56463     }
56464   }
56465
56466   jresult = (void *)result;
56467   return jresult;
56468 }
56469
56470
56471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56472   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56473
56474   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56475   {
56476     try {
56477       delete arg1;
56478     } catch (std::out_of_range& e) {
56479       {
56480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56481       };
56482     } catch (std::exception& e) {
56483       {
56484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56485       };
56486     } catch (Dali::DaliException e) {
56487       {
56488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56489       };
56490     } catch (...) {
56491       {
56492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56493       };
56494     }
56495   }
56496
56497 }
56498
56499
56500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56501   unsigned int jresult ;
56502   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56503   bool result;
56504
56505   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56506   {
56507     try {
56508       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56509     } catch (std::out_of_range& e) {
56510       {
56511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56512       };
56513     } catch (std::exception& e) {
56514       {
56515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56516       };
56517     } catch (Dali::DaliException e) {
56518       {
56519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56520       };
56521     } catch (...) {
56522       {
56523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56524       };
56525     }
56526   }
56527
56528   jresult = result;
56529   return jresult;
56530 }
56531
56532
56533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56534   unsigned long jresult ;
56535   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56536   std::size_t result;
56537
56538   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56539   {
56540     try {
56541       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56542     } catch (std::out_of_range& e) {
56543       {
56544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56545       };
56546     } catch (std::exception& e) {
56547       {
56548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56549       };
56550     } catch (Dali::DaliException e) {
56551       {
56552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56553       };
56554     } catch (...) {
56555       {
56556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56557       };
56558     }
56559   }
56560
56561   jresult = (unsigned long)result;
56562   return jresult;
56563 }
56564
56565
56566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56567   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56568   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56569
56570   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56571   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56572   {
56573     try {
56574       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56575     } catch (std::out_of_range& e) {
56576       {
56577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56578       };
56579     } catch (std::exception& e) {
56580       {
56581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56582       };
56583     } catch (Dali::DaliException e) {
56584       {
56585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56586       };
56587     } catch (...) {
56588       {
56589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56590       };
56591     }
56592   }
56593
56594 }
56595
56596
56597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56598   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56599   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56600
56601   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56602   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56603   {
56604     try {
56605       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56606     } catch (std::out_of_range& e) {
56607       {
56608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56609       };
56610     } catch (std::exception& e) {
56611       {
56612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56613       };
56614     } catch (Dali::DaliException e) {
56615       {
56616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56617       };
56618     } catch (...) {
56619       {
56620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56621       };
56622     }
56623   }
56624
56625 }
56626
56627
56628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56629   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56630   Dali::TouchData *arg2 = 0 ;
56631
56632   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56633   arg2 = (Dali::TouchData *)jarg2;
56634   if (!arg2) {
56635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56636     return ;
56637   }
56638   {
56639     try {
56640       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56641     } catch (std::out_of_range& e) {
56642       {
56643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56644       };
56645     } catch (std::exception& e) {
56646       {
56647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56648       };
56649     } catch (Dali::DaliException e) {
56650       {
56651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56652       };
56653     } catch (...) {
56654       {
56655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56656       };
56657     }
56658   }
56659
56660 }
56661
56662
56663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56664   void * jresult ;
56665   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56666
56667   {
56668     try {
56669       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56670     } catch (std::out_of_range& e) {
56671       {
56672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56673       };
56674     } catch (std::exception& e) {
56675       {
56676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56677       };
56678     } catch (Dali::DaliException e) {
56679       {
56680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56681       };
56682     } catch (...) {
56683       {
56684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56685       };
56686     }
56687   }
56688
56689   jresult = (void *)result;
56690   return jresult;
56691 }
56692
56693
56694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56695   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56696
56697   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56698   {
56699     try {
56700       delete arg1;
56701     } catch (std::out_of_range& e) {
56702       {
56703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56704       };
56705     } catch (std::exception& e) {
56706       {
56707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56708       };
56709     } catch (Dali::DaliException e) {
56710       {
56711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56712       };
56713     } catch (...) {
56714       {
56715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56716       };
56717     }
56718   }
56719
56720 }
56721
56722
56723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56724   unsigned int jresult ;
56725   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56726   bool result;
56727
56728   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56729   {
56730     try {
56731       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56732     } catch (std::out_of_range& e) {
56733       {
56734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56735       };
56736     } catch (std::exception& e) {
56737       {
56738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56739       };
56740     } catch (Dali::DaliException e) {
56741       {
56742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56743       };
56744     } catch (...) {
56745       {
56746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56747       };
56748     }
56749   }
56750
56751   jresult = result;
56752   return jresult;
56753 }
56754
56755
56756 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56757   unsigned long jresult ;
56758   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56759   std::size_t result;
56760
56761   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56762   {
56763     try {
56764       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56765     } catch (std::out_of_range& e) {
56766       {
56767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56768       };
56769     } catch (std::exception& e) {
56770       {
56771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56772       };
56773     } catch (Dali::DaliException e) {
56774       {
56775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56776       };
56777     } catch (...) {
56778       {
56779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56780       };
56781     }
56782   }
56783
56784   jresult = (unsigned long)result;
56785   return jresult;
56786 }
56787
56788
56789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56790   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56791   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56792
56793   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56794   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56795   {
56796     try {
56797       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56798     } catch (std::out_of_range& e) {
56799       {
56800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56801       };
56802     } catch (std::exception& e) {
56803       {
56804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56805       };
56806     } catch (Dali::DaliException e) {
56807       {
56808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56809       };
56810     } catch (...) {
56811       {
56812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56813       };
56814     }
56815   }
56816
56817 }
56818
56819
56820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56821   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56822   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56823
56824   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56825   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56826   {
56827     try {
56828       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56829     } catch (std::out_of_range& e) {
56830       {
56831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56832       };
56833     } catch (std::exception& e) {
56834       {
56835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56836       };
56837     } catch (Dali::DaliException e) {
56838       {
56839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56840       };
56841     } catch (...) {
56842       {
56843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56844       };
56845     }
56846   }
56847
56848 }
56849
56850
56851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56852   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56853   Dali::WheelEvent *arg2 = 0 ;
56854
56855   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56856   arg2 = (Dali::WheelEvent *)jarg2;
56857   if (!arg2) {
56858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56859     return ;
56860   }
56861   {
56862     try {
56863       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56864     } catch (std::out_of_range& e) {
56865       {
56866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56867       };
56868     } catch (std::exception& e) {
56869       {
56870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56871       };
56872     } catch (Dali::DaliException e) {
56873       {
56874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56875       };
56876     } catch (...) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56879       };
56880     }
56881   }
56882
56883 }
56884
56885
56886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56887   void * jresult ;
56888   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56889
56890   {
56891     try {
56892       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56893     } catch (std::out_of_range& e) {
56894       {
56895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56896       };
56897     } catch (std::exception& e) {
56898       {
56899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56900       };
56901     } catch (Dali::DaliException e) {
56902       {
56903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56904       };
56905     } catch (...) {
56906       {
56907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56908       };
56909     }
56910   }
56911
56912   jresult = (void *)result;
56913   return jresult;
56914 }
56915
56916
56917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56918   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56919
56920   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56921   {
56922     try {
56923       delete arg1;
56924     } catch (std::out_of_range& e) {
56925       {
56926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56927       };
56928     } catch (std::exception& e) {
56929       {
56930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56931       };
56932     } catch (Dali::DaliException e) {
56933       {
56934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56935       };
56936     } catch (...) {
56937       {
56938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56939       };
56940     }
56941   }
56942
56943 }
56944
56945
56946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56947   void * jresult ;
56948   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56949
56950   {
56951     try {
56952       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56953     } catch (std::out_of_range& e) {
56954       {
56955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (std::exception& e) {
56958       {
56959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56960       };
56961     } catch (Dali::DaliException e) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56964       };
56965     } catch (...) {
56966       {
56967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56968       };
56969     }
56970   }
56971
56972   jresult = (void *)result;
56973   return jresult;
56974 }
56975
56976
56977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56978   void * jresult ;
56979   Dali::Radian arg1 ;
56980   Dali::Radian arg2 ;
56981   Dali::Radian *argp1 ;
56982   Dali::Radian *argp2 ;
56983   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56984
56985   argp1 = (Dali::Radian *)jarg1;
56986   if (!argp1) {
56987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56988     return 0;
56989   }
56990   arg1 = *argp1;
56991   argp2 = (Dali::Radian *)jarg2;
56992   if (!argp2) {
56993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56994     return 0;
56995   }
56996   arg2 = *argp2;
56997   {
56998     try {
56999       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57000     } catch (std::out_of_range& e) {
57001       {
57002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57003       };
57004     } catch (std::exception& e) {
57005       {
57006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57007       };
57008     } catch (Dali::DaliException e) {
57009       {
57010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57011       };
57012     } catch (...) {
57013       {
57014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57015       };
57016     }
57017   }
57018
57019   jresult = (void *)result;
57020   return jresult;
57021 }
57022
57023
57024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57025   void * jresult ;
57026   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57027   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57028
57029   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57030   if (!arg1) {
57031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57032     return 0;
57033   }
57034   {
57035     try {
57036       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57037     } catch (std::out_of_range& e) {
57038       {
57039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57040       };
57041     } catch (std::exception& e) {
57042       {
57043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57044       };
57045     } catch (Dali::DaliException e) {
57046       {
57047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57048       };
57049     } catch (...) {
57050       {
57051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57052       };
57053     }
57054   }
57055
57056   jresult = (void *)result;
57057   return jresult;
57058 }
57059
57060
57061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57062   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57063   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57064
57065   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57066   arg2 = (Dali::Radian *)jarg2;
57067   if (arg1) (arg1)->first = *arg2;
57068 }
57069
57070
57071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57072   void * jresult ;
57073   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57074   Dali::Radian *result = 0 ;
57075
57076   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57077   result = (Dali::Radian *)& ((arg1)->first);
57078   jresult = (void *)result;
57079   return jresult;
57080 }
57081
57082
57083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57084   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57085   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57086
57087   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57088   arg2 = (Dali::Radian *)jarg2;
57089   if (arg1) (arg1)->second = *arg2;
57090 }
57091
57092
57093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57094   void * jresult ;
57095   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57096   Dali::Radian *result = 0 ;
57097
57098   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57099   result = (Dali::Radian *)& ((arg1)->second);
57100   jresult = (void *)result;
57101   return jresult;
57102 }
57103
57104
57105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57106   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57107
57108   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57109   {
57110     try {
57111       delete arg1;
57112     } catch (std::out_of_range& e) {
57113       {
57114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57115       };
57116     } catch (std::exception& e) {
57117       {
57118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57119       };
57120     } catch (Dali::DaliException e) {
57121       {
57122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57123       };
57124     } catch (...) {
57125       {
57126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57127       };
57128     }
57129   }
57130
57131 }
57132
57133
57134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57135   unsigned int jresult ;
57136   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57137   bool result;
57138
57139   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57140   {
57141     try {
57142       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);
57143     } catch (std::out_of_range& e) {
57144       {
57145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57146       };
57147     } catch (std::exception& e) {
57148       {
57149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57150       };
57151     } catch (Dali::DaliException e) {
57152       {
57153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57154       };
57155     } catch (...) {
57156       {
57157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57158       };
57159     }
57160   }
57161
57162   jresult = result;
57163   return jresult;
57164 }
57165
57166
57167 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57168   unsigned long jresult ;
57169   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57170   std::size_t result;
57171
57172   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57173   {
57174     try {
57175       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);
57176     } catch (std::out_of_range& e) {
57177       {
57178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57179       };
57180     } catch (std::exception& e) {
57181       {
57182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57183       };
57184     } catch (Dali::DaliException e) {
57185       {
57186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57187       };
57188     } catch (...) {
57189       {
57190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57191       };
57192     }
57193   }
57194
57195   jresult = (unsigned long)result;
57196   return jresult;
57197 }
57198
57199
57200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57201   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57202   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57203
57204   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57205   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57206   {
57207     try {
57208       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57209     } catch (std::out_of_range& e) {
57210       {
57211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57212       };
57213     } catch (std::exception& e) {
57214       {
57215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57216       };
57217     } catch (Dali::DaliException e) {
57218       {
57219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57220       };
57221     } catch (...) {
57222       {
57223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57224       };
57225     }
57226   }
57227
57228 }
57229
57230
57231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57232   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57233   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57234
57235   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57236   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57237   {
57238     try {
57239       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57240     } catch (std::out_of_range& e) {
57241       {
57242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57243       };
57244     } catch (std::exception& e) {
57245       {
57246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57247       };
57248     } catch (Dali::DaliException e) {
57249       {
57250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57251       };
57252     } catch (...) {
57253       {
57254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57255       };
57256     }
57257   }
57258
57259 }
57260
57261
57262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57263   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57264   Dali::Actor arg2 ;
57265   Dali::PanGesture *arg3 = 0 ;
57266   Dali::Actor *argp2 ;
57267
57268   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57269   argp2 = (Dali::Actor *)jarg2;
57270   if (!argp2) {
57271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57272     return ;
57273   }
57274   arg2 = *argp2;
57275   arg3 = (Dali::PanGesture *)jarg3;
57276   if (!arg3) {
57277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57278     return ;
57279   }
57280   {
57281     try {
57282       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57283     } catch (std::out_of_range& e) {
57284       {
57285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57286       };
57287     } catch (std::exception& e) {
57288       {
57289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57290       };
57291     } catch (Dali::DaliException e) {
57292       {
57293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57294       };
57295     } catch (...) {
57296       {
57297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57298       };
57299     }
57300   }
57301
57302 }
57303
57304
57305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57306   void * jresult ;
57307   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57308
57309   {
57310     try {
57311       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57312     } catch (std::out_of_range& e) {
57313       {
57314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57315       };
57316     } catch (std::exception& e) {
57317       {
57318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57319       };
57320     } catch (Dali::DaliException e) {
57321       {
57322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57323       };
57324     } catch (...) {
57325       {
57326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57327       };
57328     }
57329   }
57330
57331   jresult = (void *)result;
57332   return jresult;
57333 }
57334
57335
57336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57337   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57338
57339   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57340   {
57341     try {
57342       delete arg1;
57343     } catch (std::out_of_range& e) {
57344       {
57345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57346       };
57347     } catch (std::exception& e) {
57348       {
57349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57350       };
57351     } catch (Dali::DaliException e) {
57352       {
57353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57354       };
57355     } catch (...) {
57356       {
57357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57358       };
57359     }
57360   }
57361
57362 }
57363
57364
57365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57366   unsigned int jresult ;
57367   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57368   bool result;
57369
57370   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57371   {
57372     try {
57373       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);
57374     } catch (std::out_of_range& e) {
57375       {
57376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57377       };
57378     } catch (std::exception& e) {
57379       {
57380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57381       };
57382     } catch (Dali::DaliException e) {
57383       {
57384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57385       };
57386     } catch (...) {
57387       {
57388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57389       };
57390     }
57391   }
57392
57393   jresult = result;
57394   return jresult;
57395 }
57396
57397
57398 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57399   unsigned long jresult ;
57400   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57401   std::size_t result;
57402
57403   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57404   {
57405     try {
57406       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);
57407     } catch (std::out_of_range& e) {
57408       {
57409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57410       };
57411     } catch (std::exception& e) {
57412       {
57413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57414       };
57415     } catch (Dali::DaliException e) {
57416       {
57417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57418       };
57419     } catch (...) {
57420       {
57421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57422       };
57423     }
57424   }
57425
57426   jresult = (unsigned long)result;
57427   return jresult;
57428 }
57429
57430
57431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57432   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57433   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57434
57435   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57436   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57437   {
57438     try {
57439       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57440     } catch (std::out_of_range& e) {
57441       {
57442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57443       };
57444     } catch (std::exception& e) {
57445       {
57446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57447       };
57448     } catch (Dali::DaliException e) {
57449       {
57450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57451       };
57452     } catch (...) {
57453       {
57454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57455       };
57456     }
57457   }
57458
57459 }
57460
57461
57462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57463   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57464   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57465
57466   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57467   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57468   {
57469     try {
57470       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57471     } catch (std::out_of_range& e) {
57472       {
57473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57474       };
57475     } catch (std::exception& e) {
57476       {
57477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57478       };
57479     } catch (Dali::DaliException e) {
57480       {
57481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57482       };
57483     } catch (...) {
57484       {
57485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57486       };
57487     }
57488   }
57489
57490 }
57491
57492
57493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57494   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57495   Dali::Actor arg2 ;
57496   Dali::PinchGesture *arg3 = 0 ;
57497   Dali::Actor *argp2 ;
57498
57499   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57500   argp2 = (Dali::Actor *)jarg2;
57501   if (!argp2) {
57502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57503     return ;
57504   }
57505   arg2 = *argp2;
57506   arg3 = (Dali::PinchGesture *)jarg3;
57507   if (!arg3) {
57508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57509     return ;
57510   }
57511   {
57512     try {
57513       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57514     } catch (std::out_of_range& e) {
57515       {
57516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57517       };
57518     } catch (std::exception& e) {
57519       {
57520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57521       };
57522     } catch (Dali::DaliException e) {
57523       {
57524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57525       };
57526     } catch (...) {
57527       {
57528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57529       };
57530     }
57531   }
57532
57533 }
57534
57535
57536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57537   void * jresult ;
57538   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57539
57540   {
57541     try {
57542       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57543     } catch (std::out_of_range& e) {
57544       {
57545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57546       };
57547     } catch (std::exception& e) {
57548       {
57549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57550       };
57551     } catch (Dali::DaliException e) {
57552       {
57553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57554       };
57555     } catch (...) {
57556       {
57557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57558       };
57559     }
57560   }
57561
57562   jresult = (void *)result;
57563   return jresult;
57564 }
57565
57566
57567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57568   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57569
57570   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57571   {
57572     try {
57573       delete arg1;
57574     } catch (std::out_of_range& e) {
57575       {
57576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57577       };
57578     } catch (std::exception& e) {
57579       {
57580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57581       };
57582     } catch (Dali::DaliException e) {
57583       {
57584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57585       };
57586     } catch (...) {
57587       {
57588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57589       };
57590     }
57591   }
57592
57593 }
57594
57595
57596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57597   unsigned int jresult ;
57598   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57599   bool result;
57600
57601   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57602   {
57603     try {
57604       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);
57605     } catch (std::out_of_range& e) {
57606       {
57607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57608       };
57609     } catch (std::exception& e) {
57610       {
57611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57612       };
57613     } catch (Dali::DaliException e) {
57614       {
57615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57616       };
57617     } catch (...) {
57618       {
57619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57620       };
57621     }
57622   }
57623
57624   jresult = result;
57625   return jresult;
57626 }
57627
57628
57629 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57630   unsigned long jresult ;
57631   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57632   std::size_t result;
57633
57634   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57635   {
57636     try {
57637       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);
57638     } catch (std::out_of_range& e) {
57639       {
57640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57641       };
57642     } catch (std::exception& e) {
57643       {
57644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57645       };
57646     } catch (Dali::DaliException e) {
57647       {
57648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57649       };
57650     } catch (...) {
57651       {
57652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57653       };
57654     }
57655   }
57656
57657   jresult = (unsigned long)result;
57658   return jresult;
57659 }
57660
57661
57662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57663   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57664   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57665
57666   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57667   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57668   {
57669     try {
57670       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57671     } catch (std::out_of_range& e) {
57672       {
57673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57674       };
57675     } catch (std::exception& e) {
57676       {
57677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57678       };
57679     } catch (Dali::DaliException e) {
57680       {
57681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57682       };
57683     } catch (...) {
57684       {
57685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57686       };
57687     }
57688   }
57689
57690 }
57691
57692
57693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57694   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57695   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57696
57697   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57698   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57699   {
57700     try {
57701       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57702     } catch (std::out_of_range& e) {
57703       {
57704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57705       };
57706     } catch (std::exception& e) {
57707       {
57708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57709       };
57710     } catch (Dali::DaliException e) {
57711       {
57712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57713       };
57714     } catch (...) {
57715       {
57716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57717       };
57718     }
57719   }
57720
57721 }
57722
57723
57724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57725   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57726   Dali::Actor arg2 ;
57727   Dali::TapGesture *arg3 = 0 ;
57728   Dali::Actor *argp2 ;
57729
57730   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57731   argp2 = (Dali::Actor *)jarg2;
57732   if (!argp2) {
57733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57734     return ;
57735   }
57736   arg2 = *argp2;
57737   arg3 = (Dali::TapGesture *)jarg3;
57738   if (!arg3) {
57739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57740     return ;
57741   }
57742   {
57743     try {
57744       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57745     } catch (std::out_of_range& e) {
57746       {
57747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57748       };
57749     } catch (std::exception& e) {
57750       {
57751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57752       };
57753     } catch (Dali::DaliException e) {
57754       {
57755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57756       };
57757     } catch (...) {
57758       {
57759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57760       };
57761     }
57762   }
57763
57764 }
57765
57766
57767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57768   void * jresult ;
57769   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57770
57771   {
57772     try {
57773       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57774     } catch (std::out_of_range& e) {
57775       {
57776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57777       };
57778     } catch (std::exception& e) {
57779       {
57780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57781       };
57782     } catch (Dali::DaliException e) {
57783       {
57784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57785       };
57786     } catch (...) {
57787       {
57788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57789       };
57790     }
57791   }
57792
57793   jresult = (void *)result;
57794   return jresult;
57795 }
57796
57797
57798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57799   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57800
57801   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57802   {
57803     try {
57804       delete arg1;
57805     } catch (std::out_of_range& e) {
57806       {
57807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57808       };
57809     } catch (std::exception& e) {
57810       {
57811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57812       };
57813     } catch (Dali::DaliException e) {
57814       {
57815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57816       };
57817     } catch (...) {
57818       {
57819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57820       };
57821     }
57822   }
57823
57824 }
57825
57826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57827   unsigned int jresult ;
57828   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57829   bool result;
57830
57831   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57832   {
57833     try {
57834       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57835     } catch (std::out_of_range& e) {
57836       {
57837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57838       };
57839     } catch (std::exception& e) {
57840       {
57841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57842       };
57843     } catch (Dali::DaliException e) {
57844       {
57845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57846       };
57847     } catch (...) {
57848       {
57849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57850       };
57851     }
57852   }
57853
57854   jresult = result;
57855   return jresult;
57856 }
57857
57858
57859 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57860   unsigned long jresult ;
57861   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57862   std::size_t result;
57863
57864   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57865   {
57866     try {
57867       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57868     } catch (std::out_of_range& e) {
57869       {
57870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57871       };
57872     } catch (std::exception& e) {
57873       {
57874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57875       };
57876     } catch (Dali::DaliException e) {
57877       {
57878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57879       };
57880     } catch (...) {
57881       {
57882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57883       };
57884     }
57885   }
57886
57887   jresult = (unsigned long)result;
57888   return jresult;
57889 }
57890
57891
57892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57893   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57894   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57895
57896   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57897   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57898   {
57899     try {
57900       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57901     } catch (std::out_of_range& e) {
57902       {
57903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57904       };
57905     } catch (std::exception& e) {
57906       {
57907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57908       };
57909     } catch (Dali::DaliException e) {
57910       {
57911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57912       };
57913     } catch (...) {
57914       {
57915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57916       };
57917     }
57918   }
57919
57920 }
57921
57922
57923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57924   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57925   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57926
57927   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57928   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57929   {
57930     try {
57931       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57932     } catch (std::out_of_range& e) {
57933       {
57934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57935       };
57936     } catch (std::exception& e) {
57937       {
57938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57939       };
57940     } catch (Dali::DaliException e) {
57941       {
57942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57943       };
57944     } catch (...) {
57945       {
57946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57947       };
57948     }
57949   }
57950
57951 }
57952
57953
57954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57955   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57956   Dali::ResourceImage arg2 ;
57957   Dali::ResourceImage *argp2 ;
57958
57959   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57960   argp2 = (Dali::ResourceImage *)jarg2;
57961   if (!argp2) {
57962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57963     return ;
57964   }
57965   arg2 = *argp2;
57966   {
57967     try {
57968       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57969     } catch (std::out_of_range& e) {
57970       {
57971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57972       };
57973     } catch (std::exception& e) {
57974       {
57975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57976       };
57977     } catch (Dali::DaliException e) {
57978       {
57979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57980       };
57981     } catch (...) {
57982       {
57983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57984       };
57985     }
57986   }
57987
57988 }
57989
57990
57991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57992   void * jresult ;
57993   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57994
57995   {
57996     try {
57997       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57998     } catch (std::out_of_range& e) {
57999       {
58000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58001       };
58002     } catch (std::exception& e) {
58003       {
58004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58005       };
58006     } catch (Dali::DaliException e) {
58007       {
58008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58009       };
58010     } catch (...) {
58011       {
58012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58013       };
58014     }
58015   }
58016
58017   jresult = (void *)result;
58018   return jresult;
58019 }
58020
58021
58022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58023   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58024
58025   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58026   {
58027     try {
58028       delete arg1;
58029     } catch (std::out_of_range& e) {
58030       {
58031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58032       };
58033     } catch (std::exception& e) {
58034       {
58035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58036       };
58037     } catch (Dali::DaliException e) {
58038       {
58039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58040       };
58041     } catch (...) {
58042       {
58043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58044       };
58045     }
58046   }
58047
58048 }
58049
58050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58051   unsigned int jresult ;
58052   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58053   bool result = false;
58054
58055   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58056   {
58057     try {
58058       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);
58059     } catch (std::out_of_range& e) {
58060       {
58061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58062       };
58063     } catch (std::exception& e) {
58064       {
58065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58066       };
58067     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58068   }
58069   jresult = result;
58070   return jresult;
58071 }
58072
58073 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58074   unsigned long jresult ;
58075   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58076   std::size_t result = 0;
58077
58078   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58079   {
58080     try {
58081       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);
58082     } catch (std::out_of_range& e) {
58083       {
58084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58085       };
58086     } catch (std::exception& e) {
58087       {
58088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58089       };
58090     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58091   }
58092   jresult = (unsigned long)result;
58093   return jresult;
58094 }
58095
58096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58097   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58098   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58099
58100   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58101   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58102   {
58103     try {
58104       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58105     } catch (std::out_of_range& e) {
58106       {
58107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58108       };
58109     } catch (std::exception& e) {
58110       {
58111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58112       };
58113     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58114   }
58115 }
58116
58117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58118   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58119   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58120
58121   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58122   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58123   {
58124     try {
58125       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58126     } catch (std::out_of_range& e) {
58127       {
58128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58129       };
58130     } catch (std::exception& e) {
58131       {
58132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58133       };
58134     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58135   }
58136 }
58137
58138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58139   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58140   Dali::Actor arg2 ;
58141   //bool arg3 ;
58142   Dali::LayoutDirection::Type arg4 ;
58143   Dali::Actor *argp2 ;
58144
58145   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58146   argp2 = (Dali::Actor *)jarg2;
58147   if (!argp2) {
58148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58149     return ;
58150   }
58151   arg2 = *argp2;
58152   //arg3 = jarg3 ? true : false;
58153   arg4 = (Dali::LayoutDirection::Type)jarg4;
58154   {
58155     try {
58156       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58157     } catch (std::out_of_range& e) {
58158       {
58159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58160       };
58161     } catch (std::exception& e) {
58162       {
58163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58164       };
58165     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58166   }
58167 }
58168
58169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58170   void * jresult ;
58171   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58172
58173   {
58174     try {
58175       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58176     } catch (std::out_of_range& e) {
58177       {
58178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58179       };
58180     } catch (std::exception& e) {
58181       {
58182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58183       };
58184     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58185   }
58186   jresult = (void *)result;
58187   return jresult;
58188 }
58189
58190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58191   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58192
58193   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58194   {
58195     try {
58196       delete arg1;
58197     } catch (std::out_of_range& e) {
58198       {
58199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58200       };
58201     } catch (std::exception& e) {
58202       {
58203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58204       };
58205     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58206   }
58207 }
58208
58209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58210   unsigned int jresult ;
58211   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58212   bool result;
58213
58214   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58215   {
58216     try {
58217       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);
58218     } catch (std::out_of_range& e) {
58219       {
58220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58221       };
58222     } catch (std::exception& e) {
58223       {
58224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (Dali::DaliException e) {
58227       {
58228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58229       };
58230     } catch (...) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58233       };
58234     }
58235   }
58236
58237   jresult = result;
58238   return jresult;
58239 }
58240
58241
58242 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58243   unsigned long jresult ;
58244   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58245   std::size_t result;
58246
58247   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58248   {
58249     try {
58250       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);
58251     } catch (std::out_of_range& e) {
58252       {
58253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58254       };
58255     } catch (std::exception& e) {
58256       {
58257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58258       };
58259     } catch (Dali::DaliException e) {
58260       {
58261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58262       };
58263     } catch (...) {
58264       {
58265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58266       };
58267     }
58268   }
58269
58270   jresult = (unsigned long)result;
58271   return jresult;
58272 }
58273
58274
58275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58276   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58277   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58278
58279   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58280   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58281   {
58282     try {
58283       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58284     } catch (std::out_of_range& e) {
58285       {
58286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58287       };
58288     } catch (std::exception& e) {
58289       {
58290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58291       };
58292     } catch (Dali::DaliException e) {
58293       {
58294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58295       };
58296     } catch (...) {
58297       {
58298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58299       };
58300     }
58301   }
58302
58303 }
58304
58305
58306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58307   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58308   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58309
58310   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58311   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58312   {
58313     try {
58314       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58315     } catch (std::out_of_range& e) {
58316       {
58317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58318       };
58319     } catch (std::exception& e) {
58320       {
58321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58322       };
58323     } catch (Dali::DaliException e) {
58324       {
58325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58326       };
58327     } catch (...) {
58328       {
58329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58330       };
58331     }
58332   }
58333
58334 }
58335
58336
58337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58338   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58339   Dali::Actor arg2 ;
58340   bool arg3 ;
58341   Dali::DevelActor::VisibilityChange::Type arg4 ;
58342   Dali::Actor *argp2 ;
58343
58344   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58345   argp2 = (Dali::Actor *)jarg2;
58346   if (!argp2) {
58347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58348     return ;
58349   }
58350   arg2 = *argp2;
58351   arg3 = jarg3 ? true : false;
58352   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58353   {
58354     try {
58355       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58356     } catch (std::out_of_range& e) {
58357       {
58358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58359       };
58360     } catch (std::exception& e) {
58361       {
58362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58363       };
58364     } catch (Dali::DaliException e) {
58365       {
58366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58367       };
58368     } catch (...) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58371       };
58372     }
58373   }
58374
58375 }
58376
58377
58378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58379   void * jresult ;
58380   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58381
58382   {
58383     try {
58384       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58385     } catch (std::out_of_range& e) {
58386       {
58387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58388       };
58389     } catch (std::exception& e) {
58390       {
58391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58392       };
58393     } catch (Dali::DaliException e) {
58394       {
58395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58396       };
58397     } catch (...) {
58398       {
58399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58400       };
58401     }
58402   }
58403
58404   jresult = (void *)result;
58405   return jresult;
58406 }
58407
58408
58409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58410   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58411
58412   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58413   {
58414     try {
58415       delete arg1;
58416     } catch (std::out_of_range& e) {
58417       {
58418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58419       };
58420     } catch (std::exception& e) {
58421       {
58422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58423       };
58424     } catch (Dali::DaliException e) {
58425       {
58426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58427       };
58428     } catch (...) {
58429       {
58430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58431       };
58432     }
58433   }
58434
58435 }
58436
58437
58438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58439   void * jresult ;
58440   Dali::Timer *result = 0 ;
58441
58442   {
58443     try {
58444       result = (Dali::Timer *)new Dali::Timer();
58445     } catch (std::out_of_range& e) {
58446       {
58447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58448       };
58449     } catch (std::exception& e) {
58450       {
58451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58452       };
58453     } catch (Dali::DaliException e) {
58454       {
58455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58456       };
58457     } catch (...) {
58458       {
58459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58460       };
58461     }
58462   }
58463
58464   jresult = (void *)result;
58465   return jresult;
58466 }
58467
58468
58469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58470   void * jresult ;
58471   unsigned int arg1 ;
58472   Dali::Timer result;
58473
58474   arg1 = (unsigned int)jarg1;
58475   {
58476     try {
58477       result = Dali::Timer::New(arg1);
58478     } catch (std::out_of_range& e) {
58479       {
58480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58481       };
58482     } catch (std::exception& e) {
58483       {
58484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58485       };
58486     } catch (Dali::DaliException e) {
58487       {
58488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58489       };
58490     } catch (...) {
58491       {
58492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58493       };
58494     }
58495   }
58496
58497   jresult = new Dali::Timer((const Dali::Timer &)result);
58498   return jresult;
58499 }
58500
58501
58502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58503   void * jresult ;
58504   Dali::Timer *arg1 = 0 ;
58505   Dali::Timer *result = 0 ;
58506
58507   arg1 = (Dali::Timer *)jarg1;
58508   if (!arg1) {
58509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58510     return 0;
58511   }
58512   {
58513     try {
58514       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
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_Timer_Assign(void * jarg1, void * jarg2) {
58540   void * jresult ;
58541   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58542   Dali::Timer *arg2 = 0 ;
58543   Dali::Timer *result = 0 ;
58544
58545   arg1 = (Dali::Timer *)jarg1;
58546   arg2 = (Dali::Timer *)jarg2;
58547   if (!arg2) {
58548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58549     return 0;
58550   }
58551   {
58552     try {
58553       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58554     } catch (std::out_of_range& e) {
58555       {
58556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58557       };
58558     } catch (std::exception& e) {
58559       {
58560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58561       };
58562     } catch (Dali::DaliException e) {
58563       {
58564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58565       };
58566     } catch (...) {
58567       {
58568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58569       };
58570     }
58571   }
58572
58573   jresult = (void *)result;
58574   return jresult;
58575 }
58576
58577
58578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58579   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58580
58581   arg1 = (Dali::Timer *)jarg1;
58582   {
58583     try {
58584       delete arg1;
58585     } catch (std::out_of_range& e) {
58586       {
58587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58588       };
58589     } catch (std::exception& e) {
58590       {
58591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58592       };
58593     } catch (Dali::DaliException e) {
58594       {
58595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58596       };
58597     } catch (...) {
58598       {
58599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58600       };
58601     }
58602   }
58603
58604 }
58605
58606
58607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58608   void * jresult ;
58609   Dali::BaseHandle arg1 ;
58610   Dali::BaseHandle *argp1 ;
58611   Dali::Timer result;
58612
58613   argp1 = (Dali::BaseHandle *)jarg1;
58614   if (!argp1) {
58615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58616     return 0;
58617   }
58618   arg1 = *argp1;
58619   {
58620     try {
58621       result = Dali::Timer::DownCast(arg1);
58622     } catch (std::out_of_range& e) {
58623       {
58624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58625       };
58626     } catch (std::exception& e) {
58627       {
58628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58629       };
58630     } catch (Dali::DaliException e) {
58631       {
58632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58633       };
58634     } catch (...) {
58635       {
58636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58637       };
58638     }
58639   }
58640
58641   jresult = new Dali::Timer((const Dali::Timer &)result);
58642   return jresult;
58643 }
58644
58645
58646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58647   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58648
58649   arg1 = (Dali::Timer *)jarg1;
58650   {
58651     try {
58652       (arg1)->Start();
58653     } catch (std::out_of_range& e) {
58654       {
58655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58656       };
58657     } catch (std::exception& e) {
58658       {
58659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58660       };
58661     } catch (Dali::DaliException e) {
58662       {
58663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58664       };
58665     } catch (...) {
58666       {
58667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58668       };
58669     }
58670   }
58671
58672 }
58673
58674
58675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58676   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58677
58678   arg1 = (Dali::Timer *)jarg1;
58679   {
58680     try {
58681       (arg1)->Stop();
58682     } catch (std::out_of_range& e) {
58683       {
58684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58685       };
58686     } catch (std::exception& e) {
58687       {
58688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58689       };
58690     } catch (Dali::DaliException e) {
58691       {
58692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58693       };
58694     } catch (...) {
58695       {
58696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58697       };
58698     }
58699   }
58700
58701 }
58702
58703
58704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58705   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58706   unsigned int arg2 ;
58707
58708   arg1 = (Dali::Timer *)jarg1;
58709   arg2 = (unsigned int)jarg2;
58710   {
58711     try {
58712       (arg1)->SetInterval(arg2);
58713     } catch (std::out_of_range& e) {
58714       {
58715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58716       };
58717     } catch (std::exception& e) {
58718       {
58719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58720       };
58721     } catch (Dali::DaliException e) {
58722       {
58723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58724       };
58725     } catch (...) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58728       };
58729     }
58730   }
58731
58732 }
58733
58734
58735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58736   unsigned int jresult ;
58737   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58738   unsigned int result;
58739
58740   arg1 = (Dali::Timer *)jarg1;
58741   {
58742     try {
58743       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58744     } catch (std::out_of_range& e) {
58745       {
58746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58747       };
58748     } catch (std::exception& e) {
58749       {
58750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58751       };
58752     } catch (Dali::DaliException e) {
58753       {
58754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58755       };
58756     } catch (...) {
58757       {
58758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58759       };
58760     }
58761   }
58762
58763   jresult = result;
58764   return jresult;
58765 }
58766
58767
58768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58769   unsigned int jresult ;
58770   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58771   bool result;
58772
58773   arg1 = (Dali::Timer *)jarg1;
58774   {
58775     try {
58776       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58777     } catch (std::out_of_range& e) {
58778       {
58779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58780       };
58781     } catch (std::exception& e) {
58782       {
58783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58784       };
58785     } catch (Dali::DaliException e) {
58786       {
58787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58788       };
58789     } catch (...) {
58790       {
58791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58792       };
58793     }
58794   }
58795
58796   jresult = result;
58797   return jresult;
58798 }
58799
58800
58801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58802   void * jresult ;
58803   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58804   Dali::Timer::TimerSignalType *result = 0 ;
58805
58806   arg1 = (Dali::Timer *)jarg1;
58807   {
58808     try {
58809       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58810     } catch (std::out_of_range& e) {
58811       {
58812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58813       };
58814     } catch (std::exception& e) {
58815       {
58816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58817       };
58818     } catch (Dali::DaliException e) {
58819       {
58820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58821       };
58822     } catch (...) {
58823       {
58824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58825       };
58826     }
58827   }
58828
58829   jresult = (void *)result;
58830   return jresult;
58831 }
58832
58833
58834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58835   unsigned int jresult ;
58836   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58837   bool result;
58838
58839   arg1 = (Dali::Signal< bool () > *)jarg1;
58840   {
58841     try {
58842       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58843     } catch (std::out_of_range& e) {
58844       {
58845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58846       };
58847     } catch (std::exception& e) {
58848       {
58849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58850       };
58851     } catch (Dali::DaliException e) {
58852       {
58853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58854       };
58855     } catch (...) {
58856       {
58857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58858       };
58859     }
58860   }
58861
58862   jresult = result;
58863   return jresult;
58864 }
58865
58866
58867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58868   unsigned long jresult ;
58869   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58870   std::size_t result;
58871
58872   arg1 = (Dali::Signal< bool () > *)jarg1;
58873   {
58874     try {
58875       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58876     } catch (std::out_of_range& e) {
58877       {
58878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58879       };
58880     } catch (std::exception& e) {
58881       {
58882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58883       };
58884     } catch (Dali::DaliException e) {
58885       {
58886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58887       };
58888     } catch (...) {
58889       {
58890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58891       };
58892     }
58893   }
58894
58895   jresult = (unsigned long)result;
58896   return jresult;
58897 }
58898
58899
58900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58901   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58902   bool (*arg2)() = (bool (*)()) 0 ;
58903
58904   arg1 = (Dali::Signal< bool () > *)jarg1;
58905   arg2 = (bool (*)())jarg2;
58906   {
58907     try {
58908       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58909     } catch (std::out_of_range& e) {
58910       {
58911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58912       };
58913     } catch (std::exception& e) {
58914       {
58915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58916       };
58917     } catch (Dali::DaliException e) {
58918       {
58919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58920       };
58921     } catch (...) {
58922       {
58923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58924       };
58925     }
58926   }
58927
58928 }
58929
58930
58931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58932   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58933   bool (*arg2)() = (bool (*)()) 0 ;
58934
58935   arg1 = (Dali::Signal< bool () > *)jarg1;
58936   arg2 = (bool (*)())jarg2;
58937   {
58938     try {
58939       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58940     } catch (std::out_of_range& e) {
58941       {
58942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58943       };
58944     } catch (std::exception& e) {
58945       {
58946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58947       };
58948     } catch (Dali::DaliException e) {
58949       {
58950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58951       };
58952     } catch (...) {
58953       {
58954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58955       };
58956     }
58957   }
58958
58959 }
58960
58961
58962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58963   unsigned int jresult ;
58964   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58965   bool result;
58966
58967   arg1 = (Dali::Signal< bool () > *)jarg1;
58968   {
58969     try {
58970       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58971     } catch (std::out_of_range& e) {
58972       {
58973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58974       };
58975     } catch (std::exception& e) {
58976       {
58977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58978       };
58979     } catch (Dali::DaliException e) {
58980       {
58981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58982       };
58983     } catch (...) {
58984       {
58985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58986       };
58987     }
58988   }
58989
58990   jresult = result;
58991   return jresult;
58992 }
58993
58994
58995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
58996   void * jresult ;
58997   Dali::Signal< bool () > *result = 0 ;
58998
58999   {
59000     try {
59001       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59002     } catch (std::out_of_range& e) {
59003       {
59004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59005       };
59006     } catch (std::exception& e) {
59007       {
59008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59009       };
59010     } catch (Dali::DaliException e) {
59011       {
59012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59013       };
59014     } catch (...) {
59015       {
59016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59017       };
59018     }
59019   }
59020
59021   jresult = (void *)result;
59022   return jresult;
59023 }
59024
59025
59026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59027   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59028
59029   arg1 = (Dali::Signal< bool () > *)jarg1;
59030   {
59031     try {
59032       delete arg1;
59033     } catch (std::out_of_range& e) {
59034       {
59035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59036       };
59037     } catch (std::exception& e) {
59038       {
59039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59040       };
59041     } catch (Dali::DaliException e) {
59042       {
59043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59044       };
59045     } catch (...) {
59046       {
59047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59048       };
59049     }
59050   }
59051
59052 }
59053
59054
59055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59056   int jresult ;
59057   int result;
59058
59059   {
59060     try {
59061       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59062     } catch (std::out_of_range& e) {
59063       {
59064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59065       };
59066     } catch (std::exception& e) {
59067       {
59068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59069       };
59070     } catch (Dali::DaliException e) {
59071       {
59072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59073       };
59074     } catch (...) {
59075       {
59076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59077       };
59078     }
59079   }
59080
59081   jresult = (int)result;
59082   return jresult;
59083 }
59084
59085
59086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59087   int jresult ;
59088   int result;
59089
59090   {
59091     try {
59092       result = (int)Dali::Toolkit::Visual::Property::SHADER;
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 = (int)result;
59113   return jresult;
59114 }
59115
59116
59117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59118   int jresult ;
59119   int result;
59120
59121   {
59122     try {
59123       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59124     } catch (std::out_of_range& e) {
59125       {
59126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59127       };
59128     } catch (std::exception& e) {
59129       {
59130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59131       };
59132     } catch (Dali::DaliException e) {
59133       {
59134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59135       };
59136     } catch (...) {
59137       {
59138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59139       };
59140     }
59141   }
59142
59143   jresult = (int)result;
59144   return jresult;
59145 }
59146
59147
59148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59149   int jresult ;
59150   int result;
59151
59152   {
59153     try {
59154       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59155     } catch (std::out_of_range& e) {
59156       {
59157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59158       };
59159     } catch (std::exception& e) {
59160       {
59161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59162       };
59163     } catch (Dali::DaliException e) {
59164       {
59165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59166       };
59167     } catch (...) {
59168       {
59169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59170       };
59171     }
59172   }
59173
59174   jresult = (int)result;
59175   return jresult;
59176 }
59177
59178
59179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59180   int jresult ;
59181   int result;
59182
59183   {
59184     try {
59185       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59186     } catch (std::out_of_range& e) {
59187       {
59188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59189       };
59190     } catch (std::exception& e) {
59191       {
59192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59193       };
59194     } catch (Dali::DaliException e) {
59195       {
59196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59197       };
59198     } catch (...) {
59199       {
59200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59201       };
59202     }
59203   }
59204
59205   jresult = (int)result;
59206   return jresult;
59207 }
59208
59209
59210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59211   int jresult ;
59212   int result;
59213
59214   {
59215     try {
59216       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59217     } catch (std::out_of_range& e) {
59218       {
59219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59220       };
59221     } catch (std::exception& e) {
59222       {
59223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59224       };
59225     } catch (Dali::DaliException e) {
59226       {
59227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59228       };
59229     } catch (...) {
59230       {
59231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59232       };
59233     }
59234   }
59235
59236   jresult = (int)result;
59237   return jresult;
59238 }
59239
59240
59241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59242   int jresult ;
59243   int result;
59244
59245   {
59246     try {
59247       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59248     } catch (std::out_of_range& e) {
59249       {
59250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59251       };
59252     } catch (std::exception& e) {
59253       {
59254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59255       };
59256     } catch (Dali::DaliException e) {
59257       {
59258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59259       };
59260     } catch (...) {
59261       {
59262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59263       };
59264     }
59265   }
59266
59267   jresult = (int)result;
59268   return jresult;
59269 }
59270
59271
59272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59273   int jresult ;
59274   int result;
59275
59276   {
59277     try {
59278       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59279     } catch (std::out_of_range& e) {
59280       {
59281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59282       };
59283     } catch (std::exception& e) {
59284       {
59285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59286       };
59287     } catch (Dali::DaliException e) {
59288       {
59289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59290       };
59291     } catch (...) {
59292       {
59293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59294       };
59295     }
59296   }
59297
59298   jresult = (int)result;
59299   return jresult;
59300 }
59301
59302
59303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59304   int jresult ;
59305   int result;
59306
59307   {
59308     try {
59309       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59310     } catch (std::out_of_range& e) {
59311       {
59312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59313       };
59314     } catch (std::exception& e) {
59315       {
59316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59317       };
59318     } catch (Dali::DaliException e) {
59319       {
59320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59321       };
59322     } catch (...) {
59323       {
59324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59325       };
59326     }
59327   }
59328
59329   jresult = (int)result;
59330   return jresult;
59331 }
59332
59333
59334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59335   int jresult ;
59336   int result;
59337
59338   {
59339     try {
59340       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59341     } catch (std::out_of_range& e) {
59342       {
59343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59344       };
59345     } catch (std::exception& e) {
59346       {
59347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59348       };
59349     } catch (Dali::DaliException e) {
59350       {
59351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59352       };
59353     } catch (...) {
59354       {
59355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59356       };
59357     }
59358   }
59359
59360   jresult = (int)result;
59361   return jresult;
59362 }
59363
59364
59365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59366   int jresult ;
59367   int result;
59368
59369   {
59370     try {
59371       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59372     } catch (std::out_of_range& e) {
59373       {
59374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59375       };
59376     } catch (std::exception& e) {
59377       {
59378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59379       };
59380     } catch (Dali::DaliException e) {
59381       {
59382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59383       };
59384     } catch (...) {
59385       {
59386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59387       };
59388     }
59389   }
59390
59391   jresult = (int)result;
59392   return jresult;
59393 }
59394
59395
59396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59397   int jresult ;
59398   int result;
59399
59400   {
59401     try {
59402       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59403     } catch (std::out_of_range& e) {
59404       {
59405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59406       };
59407     } catch (std::exception& e) {
59408       {
59409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59410       };
59411     } catch (Dali::DaliException e) {
59412       {
59413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59414       };
59415     } catch (...) {
59416       {
59417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59418       };
59419     }
59420   }
59421
59422   jresult = (int)result;
59423   return jresult;
59424 }
59425
59426
59427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59428   int jresult ;
59429   int result;
59430
59431   {
59432     try {
59433       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59434     } catch (std::out_of_range& e) {
59435       {
59436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59437       };
59438     } catch (std::exception& e) {
59439       {
59440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59441       };
59442     } catch (Dali::DaliException e) {
59443       {
59444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59445       };
59446     } catch (...) {
59447       {
59448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59449       };
59450     }
59451   }
59452
59453   jresult = (int)result;
59454   return jresult;
59455 }
59456
59457
59458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59459   int jresult ;
59460   int result;
59461
59462   {
59463     try {
59464       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59465     } catch (std::out_of_range& e) {
59466       {
59467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59468       };
59469     } catch (std::exception& e) {
59470       {
59471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59472       };
59473     } catch (Dali::DaliException e) {
59474       {
59475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59476       };
59477     } catch (...) {
59478       {
59479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59480       };
59481     }
59482   }
59483
59484   jresult = (int)result;
59485   return jresult;
59486 }
59487
59488
59489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59490   int jresult ;
59491   int result;
59492
59493   {
59494     try {
59495       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59496     } catch (std::out_of_range& e) {
59497       {
59498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59499       };
59500     } catch (std::exception& e) {
59501       {
59502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59503       };
59504     } catch (Dali::DaliException e) {
59505       {
59506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59507       };
59508     } catch (...) {
59509       {
59510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59511       };
59512     }
59513   }
59514
59515   jresult = (int)result;
59516   return jresult;
59517 }
59518
59519
59520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59521   int jresult ;
59522   int result;
59523
59524   {
59525     try {
59526       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59527     } catch (std::out_of_range& e) {
59528       {
59529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59530       };
59531     } catch (std::exception& e) {
59532       {
59533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59534       };
59535     } catch (Dali::DaliException e) {
59536       {
59537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59538       };
59539     } catch (...) {
59540       {
59541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59542       };
59543     }
59544   }
59545
59546   jresult = (int)result;
59547   return jresult;
59548 }
59549
59550
59551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59552   int jresult ;
59553   int result;
59554
59555   {
59556     try {
59557       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59558     } catch (std::out_of_range& e) {
59559       {
59560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59561       };
59562     } catch (std::exception& e) {
59563       {
59564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59565       };
59566     } catch (Dali::DaliException e) {
59567       {
59568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59569       };
59570     } catch (...) {
59571       {
59572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59573       };
59574     }
59575   }
59576
59577   jresult = (int)result;
59578   return jresult;
59579 }
59580
59581
59582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59583   int jresult ;
59584   int result;
59585
59586   {
59587     try {
59588       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59589     } catch (std::out_of_range& e) {
59590       {
59591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59592       };
59593     } catch (std::exception& e) {
59594       {
59595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59596       };
59597     } catch (Dali::DaliException e) {
59598       {
59599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59600       };
59601     } catch (...) {
59602       {
59603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59604       };
59605     }
59606   }
59607
59608   jresult = (int)result;
59609   return jresult;
59610 }
59611
59612
59613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59614   int jresult ;
59615   int result;
59616
59617   {
59618     try {
59619       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59620     } catch (std::out_of_range& e) {
59621       {
59622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59623       };
59624     } catch (std::exception& e) {
59625       {
59626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59627       };
59628     } catch (Dali::DaliException e) {
59629       {
59630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59631       };
59632     } catch (...) {
59633       {
59634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59635       };
59636     }
59637   }
59638
59639   jresult = (int)result;
59640   return jresult;
59641 }
59642
59643
59644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59645   int jresult ;
59646   int result;
59647
59648   {
59649     try {
59650       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59651     } catch (std::out_of_range& e) {
59652       {
59653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59654       };
59655     } catch (std::exception& e) {
59656       {
59657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59658       };
59659     } catch (Dali::DaliException e) {
59660       {
59661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59662       };
59663     } catch (...) {
59664       {
59665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59666       };
59667     }
59668   }
59669
59670   jresult = (int)result;
59671   return jresult;
59672 }
59673
59674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59675   int jresult ;
59676   int result;
59677
59678   {
59679     try {
59680       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59681     } catch (std::out_of_range& e) {
59682       {
59683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59684       };
59685     } catch (std::exception& e) {
59686       {
59687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59688       };
59689     } catch (Dali::DaliException e) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59692       };
59693     } catch (...) {
59694       {
59695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59696       };
59697     }
59698   }
59699
59700   jresult = (int)result;
59701   return jresult;
59702 }
59703
59704
59705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59706   int jresult ;
59707   int result;
59708   {
59709     try
59710     {
59711       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59712     } catch (std::out_of_range& e) {
59713       {
59714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59715       };
59716     } catch (std::exception& e) {
59717       {
59718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (Dali::DaliException e) {
59721       {
59722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59723       };
59724     } catch (...) {
59725       {
59726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59727       };
59728     }
59729   }
59730
59731   jresult = (int)result;
59732   return jresult;
59733 }
59734
59735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59736   int jresult ;
59737   int result;
59738   {
59739     try
59740     {
59741       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59742     } catch (std::out_of_range& e) {
59743       {
59744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59745       };
59746     } catch (std::exception& e) {
59747       {
59748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59749       };
59750     } catch (Dali::DaliException e) {
59751       {
59752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59753       };
59754     } catch (...) {
59755       {
59756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59757       };
59758     }
59759   }
59760
59761   jresult = (int)result;
59762   return jresult;
59763 }
59764
59765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59766   int jresult ;
59767   int result;
59768   {
59769     try
59770     {
59771       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59772     } catch (std::out_of_range& e) {
59773       {
59774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59775       };
59776     } catch (std::exception& e) {
59777       {
59778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59779       };
59780     } catch (Dali::DaliException e) {
59781       {
59782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59783       };
59784     } catch (...) {
59785       {
59786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59787       };
59788     }
59789   }
59790
59791   jresult = (int)result;
59792   return jresult;
59793 }
59794
59795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59796   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59797 }
59798
59799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59800   int jresult ;
59801   int result;
59802   {
59803     try
59804     {
59805       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59806     } catch (std::out_of_range& e) {
59807       {
59808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59809       };
59810     } catch (std::exception& e) {
59811       {
59812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59813       };
59814     } catch (Dali::DaliException e) {
59815       {
59816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59817       };
59818     } catch (...) {
59819       {
59820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59821       };
59822     }
59823   }
59824
59825   jresult = (int)result;
59826   return jresult;
59827 }
59828
59829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59830   int jresult ;
59831   int result;
59832   {
59833     try
59834     {
59835       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59836     } catch (std::out_of_range& e) {
59837       {
59838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59839       };
59840     } catch (std::exception& e) {
59841       {
59842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59843       };
59844     } catch (Dali::DaliException e) {
59845       {
59846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59847       };
59848     } catch (...) {
59849       {
59850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59851       };
59852     }
59853   }
59854
59855   jresult = (int)result;
59856   return jresult;
59857 }
59858
59859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59860   int jresult ;
59861   int result;
59862
59863   {
59864     try {
59865       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59866     } catch (std::out_of_range& e) {
59867       {
59868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59869       };
59870     } catch (std::exception& e) {
59871       {
59872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59873       };
59874     } catch (Dali::DaliException e) {
59875       {
59876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59877       };
59878     } catch (...) {
59879       {
59880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59881       };
59882     }
59883   }
59884
59885   jresult = (int)result;
59886   return jresult;
59887 }
59888
59889
59890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59891   int jresult ;
59892   int result;
59893
59894   {
59895     try {
59896       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59897     } catch (std::out_of_range& e) {
59898       {
59899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59900       };
59901     } catch (std::exception& e) {
59902       {
59903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59904       };
59905     } catch (Dali::DaliException e) {
59906       {
59907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59908       };
59909     } catch (...) {
59910       {
59911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59912       };
59913     }
59914   }
59915
59916   jresult = (int)result;
59917   return jresult;
59918 }
59919
59920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59921   int jresult ;
59922   int result;
59923   {
59924     try
59925     {
59926       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59927     } catch (std::out_of_range& e) {
59928       {
59929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59930       };
59931     } catch (std::exception& e) {
59932       {
59933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59934       };
59935     } catch (...) {
59936       {
59937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59938       };
59939     }
59940   }
59941   jresult = (int)result;
59942   return jresult;
59943 }
59944
59945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59946   int jresult ;
59947   int result;
59948   {
59949     try
59950     {
59951       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59952     } catch (std::out_of_range& e) {
59953       {
59954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (std::exception& e) {
59957       {
59958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59959       };
59960     } catch (...) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59963       };
59964     }
59965   }
59966   jresult = (int)result;
59967   return jresult;
59968 }
59969
59970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59971   int jresult ;
59972   int result;
59973   {
59974     try
59975     {
59976       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59977     } catch (std::out_of_range& e) {
59978       {
59979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59980       };
59981     } catch (std::exception& e) {
59982       {
59983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59984       };
59985     } catch (...) {
59986       {
59987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59988       };
59989     }
59990   }
59991   jresult = (int)result;
59992   return jresult;
59993 }
59994
59995
59996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
59997   int jresult ;
59998   int result;
59999   {
60000     try
60001     {
60002       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
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 (...) {
60012       {
60013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60014       };
60015     }
60016   }
60017   jresult = (int)result;
60018   return jresult;
60019 }
60020
60021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60022   int jresult ;
60023   int result;
60024   {
60025     try
60026     {
60027       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60028     } catch (std::out_of_range& e) {
60029       {
60030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60031       };
60032     } catch (std::exception& e) {
60033       {
60034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60035       };
60036     } catch (...) {
60037       {
60038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60039       };
60040     }
60041   }
60042   jresult = (int)result;
60043   return jresult;
60044 }
60045
60046
60047
60048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60049   int jresult ;
60050   int result;
60051
60052   {
60053     try {
60054       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60055     } catch (std::out_of_range& e) {
60056       {
60057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60058       };
60059     } catch (std::exception& e) {
60060       {
60061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60062       };
60063     } catch (Dali::DaliException e) {
60064       {
60065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60066       };
60067     } catch (...) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60070       };
60071     }
60072   }
60073
60074   jresult = (int)result;
60075   return jresult;
60076 }
60077
60078
60079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60080   int jresult ;
60081   int result;
60082
60083   {
60084     try {
60085       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60086     } catch (std::out_of_range& e) {
60087       {
60088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60089       };
60090     } catch (std::exception& e) {
60091       {
60092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60093       };
60094     } catch (Dali::DaliException e) {
60095       {
60096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60097       };
60098     } catch (...) {
60099       {
60100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60101       };
60102     }
60103   }
60104
60105   jresult = (int)result;
60106   return jresult;
60107 }
60108
60109
60110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60111   int jresult ;
60112   int result;
60113
60114   {
60115     try {
60116       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60117     } catch (std::out_of_range& e) {
60118       {
60119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60120       };
60121     } catch (std::exception& e) {
60122       {
60123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60124       };
60125     } catch (Dali::DaliException e) {
60126       {
60127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60128       };
60129     } catch (...) {
60130       {
60131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60132       };
60133     }
60134   }
60135
60136   jresult = (int)result;
60137   return jresult;
60138 }
60139
60140
60141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60142   int jresult ;
60143   int result;
60144
60145   {
60146     try {
60147       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60148     } catch (std::out_of_range& e) {
60149       {
60150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60151       };
60152     } catch (std::exception& e) {
60153       {
60154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60155       };
60156     } catch (Dali::DaliException e) {
60157       {
60158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60159       };
60160     } catch (...) {
60161       {
60162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60163       };
60164     }
60165   }
60166
60167   jresult = (int)result;
60168   return jresult;
60169 }
60170
60171
60172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60173   int jresult ;
60174   int result;
60175
60176   {
60177     try {
60178       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60179     } catch (std::out_of_range& e) {
60180       {
60181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (std::exception& e) {
60184       {
60185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60186       };
60187     } catch (Dali::DaliException e) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60190       };
60191     } catch (...) {
60192       {
60193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60194       };
60195     }
60196   }
60197
60198   jresult = (int)result;
60199   return jresult;
60200 }
60201
60202
60203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60204   int jresult ;
60205   int result;
60206
60207   {
60208     try {
60209       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60210     } catch (std::out_of_range& e) {
60211       {
60212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60213       };
60214     } catch (std::exception& e) {
60215       {
60216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60217       };
60218     } catch (Dali::DaliException e) {
60219       {
60220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60221       };
60222     } catch (...) {
60223       {
60224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60225       };
60226     }
60227   }
60228
60229   jresult = (int)result;
60230   return jresult;
60231 }
60232
60233
60234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60235   int jresult ;
60236   int result;
60237
60238   {
60239     try {
60240       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60241     } catch (std::out_of_range& e) {
60242       {
60243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60244       };
60245     } catch (std::exception& e) {
60246       {
60247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60248       };
60249     } catch (Dali::DaliException e) {
60250       {
60251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60252       };
60253     } catch (...) {
60254       {
60255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60256       };
60257     }
60258   }
60259
60260   jresult = (int)result;
60261   return jresult;
60262 }
60263
60264 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60265   int jresult ;
60266   int result;
60267
60268   {
60269     try {
60270       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60271     } catch (std::out_of_range& e) {
60272       {
60273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60274       };
60275     } catch (std::exception& e) {
60276       {
60277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60278       };
60279     } catch (...) {
60280       {
60281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60282       };
60283     }
60284   }
60285   jresult = (int)result;
60286   return jresult;
60287 }
60288
60289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60290   int jresult ;
60291   int result;
60292
60293   {
60294     try {
60295       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60296     } catch (std::out_of_range& e) {
60297       {
60298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60299       };
60300     } catch (std::exception& e) {
60301       {
60302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60303       };
60304     } catch (Dali::DaliException e) {
60305       {
60306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60307       };
60308     } catch (...) {
60309       {
60310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60311       };
60312     }
60313   }
60314
60315   jresult = (int)result;
60316   return jresult;
60317 }
60318
60319
60320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60321   int jresult ;
60322   int result;
60323
60324   {
60325     try {
60326       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60327     } catch (std::out_of_range& e) {
60328       {
60329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60330       };
60331     } catch (std::exception& e) {
60332       {
60333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60334       };
60335     } catch (Dali::DaliException e) {
60336       {
60337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60338       };
60339     } catch (...) {
60340       {
60341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60342       };
60343     }
60344   }
60345
60346   jresult = (int)result;
60347   return jresult;
60348 }
60349
60350
60351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60352   int jresult ;
60353   int result;
60354
60355   {
60356     try {
60357       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60358     } catch (std::out_of_range& e) {
60359       {
60360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60361       };
60362     } catch (std::exception& e) {
60363       {
60364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60365       };
60366     } catch (Dali::DaliException e) {
60367       {
60368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60369       };
60370     } catch (...) {
60371       {
60372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60373       };
60374     }
60375   }
60376
60377   jresult = (int)result;
60378   return jresult;
60379 }
60380
60381
60382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60383   int jresult ;
60384   int result;
60385
60386   {
60387     try {
60388       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60389     } catch (std::out_of_range& e) {
60390       {
60391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60392       };
60393     } catch (std::exception& e) {
60394       {
60395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60396       };
60397     } catch (Dali::DaliException e) {
60398       {
60399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60400       };
60401     } catch (...) {
60402       {
60403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60404       };
60405     }
60406   }
60407
60408   jresult = (int)result;
60409   return jresult;
60410 }
60411
60412
60413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60414   int jresult ;
60415   int result;
60416
60417   {
60418     try {
60419       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60420     } catch (std::out_of_range& e) {
60421       {
60422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60423       };
60424     } catch (std::exception& e) {
60425       {
60426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60427       };
60428     } catch (Dali::DaliException e) {
60429       {
60430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60431       };
60432     } catch (...) {
60433       {
60434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60435       };
60436     }
60437   }
60438
60439   jresult = (int)result;
60440   return jresult;
60441 }
60442
60443
60444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60445   int jresult ;
60446   int result;
60447
60448   {
60449     try {
60450       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60451     } catch (std::out_of_range& e) {
60452       {
60453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60454       };
60455     } catch (std::exception& e) {
60456       {
60457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60458       };
60459     } catch (Dali::DaliException e) {
60460       {
60461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60462       };
60463     } catch (...) {
60464       {
60465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60466       };
60467     }
60468   }
60469
60470   jresult = (int)result;
60471   return jresult;
60472 }
60473
60474
60475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60476   int jresult ;
60477   int result;
60478
60479   {
60480     try {
60481       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60482     } catch (std::out_of_range& e) {
60483       {
60484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60485       };
60486     } catch (std::exception& e) {
60487       {
60488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60489       };
60490     } catch (Dali::DaliException e) {
60491       {
60492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60493       };
60494     } catch (...) {
60495       {
60496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60497       };
60498     }
60499   }
60500
60501   jresult = (int)result;
60502   return jresult;
60503 }
60504
60505
60506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60507   int jresult ;
60508   int result;
60509
60510   {
60511     try {
60512       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60513     } catch (std::out_of_range& e) {
60514       {
60515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60516       };
60517     } catch (std::exception& e) {
60518       {
60519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60520       };
60521     } catch (Dali::DaliException e) {
60522       {
60523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60524       };
60525     } catch (...) {
60526       {
60527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60528       };
60529     }
60530   }
60531
60532   jresult = (int)result;
60533   return jresult;
60534 }
60535
60536
60537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60538   int jresult ;
60539   int result;
60540
60541   {
60542     try {
60543       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60544     } catch (std::out_of_range& e) {
60545       {
60546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60547       };
60548     } catch (std::exception& e) {
60549       {
60550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60551       };
60552     } catch (Dali::DaliException e) {
60553       {
60554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60555       };
60556     } catch (...) {
60557       {
60558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60559       };
60560     }
60561   }
60562
60563   jresult = (int)result;
60564   return jresult;
60565 }
60566
60567
60568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60569   int jresult ;
60570   int result;
60571
60572   {
60573     try {
60574       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60575     } catch (std::out_of_range& e) {
60576       {
60577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60578       };
60579     } catch (std::exception& e) {
60580       {
60581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60582       };
60583     } catch (Dali::DaliException e) {
60584       {
60585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60586       };
60587     } catch (...) {
60588       {
60589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60590       };
60591     }
60592   }
60593
60594   jresult = (int)result;
60595   return jresult;
60596 }
60597
60598
60599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60600   int jresult ;
60601   int result;
60602
60603   {
60604     try {
60605       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60606     } catch (std::out_of_range& e) {
60607       {
60608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60609       };
60610     } catch (std::exception& e) {
60611       {
60612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60613       };
60614     } catch (Dali::DaliException e) {
60615       {
60616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60617       };
60618     } catch (...) {
60619       {
60620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60621       };
60622     }
60623   }
60624
60625   jresult = (int)result;
60626   return jresult;
60627 }
60628
60629
60630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60631   int jresult ;
60632   int result;
60633
60634   {
60635     try {
60636       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60637     } catch (std::out_of_range& e) {
60638       {
60639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60640       };
60641     } catch (std::exception& e) {
60642       {
60643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60644       };
60645     } catch (Dali::DaliException e) {
60646       {
60647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60648       };
60649     } catch (...) {
60650       {
60651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60652       };
60653     }
60654   }
60655
60656   jresult = (int)result;
60657   return jresult;
60658 }
60659
60660
60661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60662   int jresult ;
60663   int result;
60664
60665   {
60666     try {
60667       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60668     } catch (std::out_of_range& e) {
60669       {
60670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60671       };
60672     } catch (std::exception& e) {
60673       {
60674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60675       };
60676     } catch (Dali::DaliException e) {
60677       {
60678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60679       };
60680     } catch (...) {
60681       {
60682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60683       };
60684     }
60685   }
60686
60687   jresult = (int)result;
60688   return jresult;
60689 }
60690
60691
60692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60693   int jresult ;
60694   int result;
60695
60696   {
60697     try {
60698       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60699     } catch (std::out_of_range& e) {
60700       {
60701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60702       };
60703     } catch (std::exception& e) {
60704       {
60705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60706       };
60707     } catch (Dali::DaliException e) {
60708       {
60709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60710       };
60711     } catch (...) {
60712       {
60713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60714       };
60715     }
60716   }
60717
60718   jresult = (int)result;
60719   return jresult;
60720 }
60721
60722
60723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60724   int jresult ;
60725   int result;
60726
60727   {
60728     try {
60729       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60730     } catch (std::out_of_range& e) {
60731       {
60732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60733       };
60734     } catch (std::exception& e) {
60735       {
60736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60737       };
60738     } catch (Dali::DaliException e) {
60739       {
60740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60741       };
60742     } catch (...) {
60743       {
60744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60745       };
60746     }
60747   }
60748
60749   jresult = (int)result;
60750   return jresult;
60751 }
60752
60753
60754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60755   int jresult ;
60756   int result;
60757
60758   {
60759     try {
60760       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60761     } catch (std::out_of_range& e) {
60762       {
60763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60764       };
60765     } catch (std::exception& e) {
60766       {
60767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60768       };
60769     } catch (Dali::DaliException e) {
60770       {
60771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60772       };
60773     } catch (...) {
60774       {
60775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60776       };
60777     }
60778   }
60779
60780   jresult = (int)result;
60781   return jresult;
60782 }
60783
60784
60785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60786   int jresult ;
60787   int result;
60788
60789   {
60790     try {
60791       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60792     } catch (std::out_of_range& e) {
60793       {
60794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60795       };
60796     } catch (std::exception& e) {
60797       {
60798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60799       };
60800     } catch (Dali::DaliException e) {
60801       {
60802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60803       };
60804     } catch (...) {
60805       {
60806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60807       };
60808     }
60809   }
60810
60811   jresult = (int)result;
60812   return jresult;
60813 }
60814
60815
60816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60817   int jresult ;
60818   int result;
60819
60820   {
60821     try {
60822       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60823     } catch (std::out_of_range& e) {
60824       {
60825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60826       };
60827     } catch (std::exception& e) {
60828       {
60829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60830       };
60831     } catch (Dali::DaliException e) {
60832       {
60833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60834       };
60835     } catch (...) {
60836       {
60837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60838       };
60839     }
60840   }
60841
60842   jresult = (int)result;
60843   return jresult;
60844 }
60845
60846
60847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60848   int jresult ;
60849   int result;
60850
60851   {
60852     try {
60853       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60854     } catch (std::out_of_range& e) {
60855       {
60856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60857       };
60858     } catch (std::exception& e) {
60859       {
60860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60861       };
60862     } catch (Dali::DaliException e) {
60863       {
60864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60865       };
60866     } catch (...) {
60867       {
60868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60869       };
60870     }
60871   }
60872
60873   jresult = (int)result;
60874   return jresult;
60875 }
60876
60877
60878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60879   int jresult ;
60880   int result;
60881
60882   {
60883     try {
60884       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60885     } catch (std::out_of_range& e) {
60886       {
60887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60888       };
60889     } catch (std::exception& e) {
60890       {
60891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60892       };
60893     } catch (Dali::DaliException e) {
60894       {
60895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60896       };
60897     } catch (...) {
60898       {
60899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60900       };
60901     }
60902   }
60903
60904   jresult = (int)result;
60905   return jresult;
60906 }
60907
60908
60909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60910   int jresult ;
60911   int result;
60912
60913   {
60914     try {
60915       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60916     } catch (std::out_of_range& e) {
60917       {
60918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60919       };
60920     } catch (std::exception& e) {
60921       {
60922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60923       };
60924     } catch (Dali::DaliException e) {
60925       {
60926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60927       };
60928     } catch (...) {
60929       {
60930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60931       };
60932     }
60933   }
60934
60935   jresult = (int)result;
60936   return jresult;
60937 }
60938
60939
60940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60941   int jresult ;
60942   int result;
60943
60944   {
60945     try {
60946       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60947     } catch (std::out_of_range& e) {
60948       {
60949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60950       };
60951     } catch (std::exception& e) {
60952       {
60953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60954       };
60955     } catch (Dali::DaliException e) {
60956       {
60957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60958       };
60959     } catch (...) {
60960       {
60961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60962       };
60963     }
60964   }
60965
60966   jresult = (int)result;
60967   return jresult;
60968 }
60969
60970
60971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60972   int jresult ;
60973   int result;
60974
60975   {
60976     try {
60977       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60978     } catch (std::out_of_range& e) {
60979       {
60980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60981       };
60982     } catch (std::exception& e) {
60983       {
60984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60985       };
60986     } catch (Dali::DaliException e) {
60987       {
60988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60989       };
60990     } catch (...) {
60991       {
60992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60993       };
60994     }
60995   }
60996
60997   jresult = (int)result;
60998   return jresult;
60999 }
61000
61001
61002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61003   int jresult ;
61004   int result;
61005
61006   {
61007     try {
61008       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61009     } catch (std::out_of_range& e) {
61010       {
61011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61012       };
61013     } catch (std::exception& e) {
61014       {
61015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61016       };
61017     } catch (Dali::DaliException e) {
61018       {
61019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61020       };
61021     } catch (...) {
61022       {
61023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61024       };
61025     }
61026   }
61027
61028   jresult = (int)result;
61029   return jresult;
61030 }
61031
61032
61033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61034   int jresult ;
61035   int result;
61036
61037   {
61038     try {
61039       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61040     } catch (std::out_of_range& e) {
61041       {
61042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61043       };
61044     } catch (std::exception& e) {
61045       {
61046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61047       };
61048     } catch (Dali::DaliException e) {
61049       {
61050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61051       };
61052     } catch (...) {
61053       {
61054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61055       };
61056     }
61057   }
61058
61059   jresult = (int)result;
61060   return jresult;
61061 }
61062
61063
61064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61065   int jresult ;
61066   int result;
61067
61068   {
61069     try {
61070       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61071     } catch (std::out_of_range& e) {
61072       {
61073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61074       };
61075     } catch (std::exception& e) {
61076       {
61077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61078       };
61079     } catch (Dali::DaliException e) {
61080       {
61081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61082       };
61083     } catch (...) {
61084       {
61085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61086       };
61087     }
61088   }
61089
61090   jresult = (int)result;
61091   return jresult;
61092 }
61093
61094
61095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61096   int jresult ;
61097   int result;
61098
61099   {
61100     try {
61101       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61102     } catch (std::out_of_range& e) {
61103       {
61104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61105       };
61106     } catch (std::exception& e) {
61107       {
61108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61109       };
61110     } catch (Dali::DaliException e) {
61111       {
61112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61113       };
61114     } catch (...) {
61115       {
61116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61117       };
61118     }
61119   }
61120
61121   jresult = (int)result;
61122   return jresult;
61123 }
61124
61125
61126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61127   int jresult ;
61128   int result;
61129
61130   {
61131     try {
61132       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61133     } catch (std::out_of_range& e) {
61134       {
61135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61136       };
61137     } catch (std::exception& e) {
61138       {
61139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61140       };
61141     } catch (Dali::DaliException e) {
61142       {
61143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61144       };
61145     } catch (...) {
61146       {
61147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61148       };
61149     }
61150   }
61151
61152   jresult = (int)result;
61153   return jresult;
61154 }
61155
61156
61157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61158   void * jresult ;
61159   Dali::Toolkit::Builder *result = 0 ;
61160
61161   {
61162     try {
61163       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61164     } catch (std::out_of_range& e) {
61165       {
61166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61167       };
61168     } catch (std::exception& e) {
61169       {
61170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61171       };
61172     } catch (Dali::DaliException e) {
61173       {
61174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61175       };
61176     } catch (...) {
61177       {
61178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61179       };
61180     }
61181   }
61182
61183   jresult = (void *)result;
61184   return jresult;
61185 }
61186
61187
61188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61189   void * jresult ;
61190   Dali::Toolkit::Builder result;
61191
61192   {
61193     try {
61194       result = Dali::Toolkit::Builder::New();
61195     } catch (std::out_of_range& e) {
61196       {
61197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61198       };
61199     } catch (std::exception& e) {
61200       {
61201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61202       };
61203     } catch (Dali::DaliException e) {
61204       {
61205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61206       };
61207     } catch (...) {
61208       {
61209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61210       };
61211     }
61212   }
61213
61214   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61215   return jresult;
61216 }
61217
61218
61219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61220   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61221
61222   arg1 = (Dali::Toolkit::Builder *)jarg1;
61223   {
61224     try {
61225       delete arg1;
61226     } catch (std::out_of_range& e) {
61227       {
61228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61229       };
61230     } catch (std::exception& e) {
61231       {
61232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61233       };
61234     } catch (Dali::DaliException e) {
61235       {
61236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61237       };
61238     } catch (...) {
61239       {
61240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61241       };
61242     }
61243   }
61244
61245 }
61246
61247
61248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61249   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61250   std::string *arg2 = 0 ;
61251   Dali::Toolkit::Builder::UIFormat arg3 ;
61252
61253   arg1 = (Dali::Toolkit::Builder *)jarg1;
61254   if (!jarg2) {
61255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61256     return ;
61257   }
61258   std::string arg2_str(jarg2);
61259   arg2 = &arg2_str;
61260   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61261   {
61262     try {
61263       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61264     } catch (std::out_of_range& e) {
61265       {
61266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61267       };
61268     } catch (std::exception& e) {
61269       {
61270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61271       };
61272     } catch (Dali::DaliException e) {
61273       {
61274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61275       };
61276     } catch (...) {
61277       {
61278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61279       };
61280     }
61281   }
61282
61283
61284   //argout typemap for const std::string&
61285
61286 }
61287
61288
61289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61290   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61291   std::string *arg2 = 0 ;
61292
61293   arg1 = (Dali::Toolkit::Builder *)jarg1;
61294   if (!jarg2) {
61295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61296     return ;
61297   }
61298   std::string arg2_str(jarg2);
61299   arg2 = &arg2_str;
61300   {
61301     try {
61302       (arg1)->LoadFromString((std::string const &)*arg2);
61303     } catch (std::out_of_range& e) {
61304       {
61305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61306       };
61307     } catch (std::exception& e) {
61308       {
61309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61310       };
61311     } catch (Dali::DaliException e) {
61312       {
61313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61314       };
61315     } catch (...) {
61316       {
61317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61318       };
61319     }
61320   }
61321
61322
61323   //argout typemap for const std::string&
61324
61325 }
61326
61327
61328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61329   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61330   Dali::Property::Map *arg2 = 0 ;
61331
61332   arg1 = (Dali::Toolkit::Builder *)jarg1;
61333   arg2 = (Dali::Property::Map *)jarg2;
61334   if (!arg2) {
61335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61336     return ;
61337   }
61338   {
61339     try {
61340       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61341     } catch (std::out_of_range& e) {
61342       {
61343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61344       };
61345     } catch (std::exception& e) {
61346       {
61347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61348       };
61349     } catch (Dali::DaliException e) {
61350       {
61351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61352       };
61353     } catch (...) {
61354       {
61355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61356       };
61357     }
61358   }
61359
61360 }
61361
61362
61363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61364   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61365   std::string *arg2 = 0 ;
61366   Dali::Property::Value *arg3 = 0 ;
61367
61368   arg1 = (Dali::Toolkit::Builder *)jarg1;
61369   if (!jarg2) {
61370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61371     return ;
61372   }
61373   std::string arg2_str(jarg2);
61374   arg2 = &arg2_str;
61375   arg3 = (Dali::Property::Value *)jarg3;
61376   if (!arg3) {
61377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61378     return ;
61379   }
61380   {
61381     try {
61382       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61383     } catch (std::out_of_range& e) {
61384       {
61385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61386       };
61387     } catch (std::exception& e) {
61388       {
61389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61390       };
61391     } catch (Dali::DaliException e) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61394       };
61395     } catch (...) {
61396       {
61397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61398       };
61399     }
61400   }
61401
61402
61403   //argout typemap for const std::string&
61404
61405 }
61406
61407
61408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61409   void * jresult ;
61410   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61411   Dali::Property::Map *result = 0 ;
61412
61413   arg1 = (Dali::Toolkit::Builder *)jarg1;
61414   {
61415     try {
61416       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61417     } catch (std::out_of_range& e) {
61418       {
61419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61420       };
61421     } catch (std::exception& e) {
61422       {
61423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61424       };
61425     } catch (Dali::DaliException e) {
61426       {
61427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61428       };
61429     } catch (...) {
61430       {
61431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61432       };
61433     }
61434   }
61435
61436   jresult = (void *)result;
61437   return jresult;
61438 }
61439
61440
61441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61442   void * jresult ;
61443   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61444   std::string *arg2 = 0 ;
61445   Dali::Property::Value *result = 0 ;
61446
61447   arg1 = (Dali::Toolkit::Builder *)jarg1;
61448   if (!jarg2) {
61449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61450     return 0;
61451   }
61452   std::string arg2_str(jarg2);
61453   arg2 = &arg2_str;
61454   {
61455     try {
61456       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61457     } catch (std::out_of_range& e) {
61458       {
61459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61460       };
61461     } catch (std::exception& e) {
61462       {
61463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61464       };
61465     } catch (Dali::DaliException e) {
61466       {
61467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61468       };
61469     } catch (...) {
61470       {
61471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61472       };
61473     }
61474   }
61475
61476   jresult = (void *)result;
61477
61478   //argout typemap for const std::string&
61479
61480   return jresult;
61481 }
61482
61483
61484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61485   void * jresult ;
61486   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61487   std::string *arg2 = 0 ;
61488   Dali::Animation result;
61489
61490   arg1 = (Dali::Toolkit::Builder *)jarg1;
61491   if (!jarg2) {
61492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61493     return 0;
61494   }
61495   std::string arg2_str(jarg2);
61496   arg2 = &arg2_str;
61497   {
61498     try {
61499       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61500     } catch (std::out_of_range& e) {
61501       {
61502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61503       };
61504     } catch (std::exception& e) {
61505       {
61506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61507       };
61508     } catch (Dali::DaliException e) {
61509       {
61510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61511       };
61512     } catch (...) {
61513       {
61514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61515       };
61516     }
61517   }
61518
61519   jresult = new Dali::Animation((const Dali::Animation &)result);
61520
61521   //argout typemap for const std::string&
61522
61523   return jresult;
61524 }
61525
61526
61527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61528   void * jresult ;
61529   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61530   std::string *arg2 = 0 ;
61531   Dali::Property::Map *arg3 = 0 ;
61532   Dali::Animation result;
61533
61534   arg1 = (Dali::Toolkit::Builder *)jarg1;
61535   if (!jarg2) {
61536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61537     return 0;
61538   }
61539   std::string arg2_str(jarg2);
61540   arg2 = &arg2_str;
61541   arg3 = (Dali::Property::Map *)jarg3;
61542   if (!arg3) {
61543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61544     return 0;
61545   }
61546   {
61547     try {
61548       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61549     } catch (std::out_of_range& e) {
61550       {
61551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61552       };
61553     } catch (std::exception& e) {
61554       {
61555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61556       };
61557     } catch (Dali::DaliException e) {
61558       {
61559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61560       };
61561     } catch (...) {
61562       {
61563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61564       };
61565     }
61566   }
61567
61568   jresult = new Dali::Animation((const Dali::Animation &)result);
61569
61570   //argout typemap for const std::string&
61571
61572   return jresult;
61573 }
61574
61575
61576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61577   void * jresult ;
61578   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61579   std::string *arg2 = 0 ;
61580   Dali::Actor arg3 ;
61581   Dali::Actor *argp3 ;
61582   Dali::Animation result;
61583
61584   arg1 = (Dali::Toolkit::Builder *)jarg1;
61585   if (!jarg2) {
61586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61587     return 0;
61588   }
61589   std::string arg2_str(jarg2);
61590   arg2 = &arg2_str;
61591   argp3 = (Dali::Actor *)jarg3;
61592   if (!argp3) {
61593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61594     return 0;
61595   }
61596   arg3 = *argp3;
61597   {
61598     try {
61599       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61600     } catch (std::out_of_range& e) {
61601       {
61602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61603       };
61604     } catch (std::exception& e) {
61605       {
61606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61607       };
61608     } catch (Dali::DaliException e) {
61609       {
61610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61611       };
61612     } catch (...) {
61613       {
61614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61615       };
61616     }
61617   }
61618
61619   jresult = new Dali::Animation((const Dali::Animation &)result);
61620
61621   //argout typemap for const std::string&
61622
61623   return jresult;
61624 }
61625
61626
61627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61628   void * jresult ;
61629   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61630   std::string *arg2 = 0 ;
61631   Dali::Property::Map *arg3 = 0 ;
61632   Dali::Actor arg4 ;
61633   Dali::Actor *argp4 ;
61634   Dali::Animation result;
61635
61636   arg1 = (Dali::Toolkit::Builder *)jarg1;
61637   if (!jarg2) {
61638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61639     return 0;
61640   }
61641   std::string arg2_str(jarg2);
61642   arg2 = &arg2_str;
61643   arg3 = (Dali::Property::Map *)jarg3;
61644   if (!arg3) {
61645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61646     return 0;
61647   }
61648   argp4 = (Dali::Actor *)jarg4;
61649   if (!argp4) {
61650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61651     return 0;
61652   }
61653   arg4 = *argp4;
61654   {
61655     try {
61656       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61657     } catch (std::out_of_range& e) {
61658       {
61659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61660       };
61661     } catch (std::exception& e) {
61662       {
61663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61664       };
61665     } catch (Dali::DaliException e) {
61666       {
61667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61668       };
61669     } catch (...) {
61670       {
61671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61672       };
61673     }
61674   }
61675
61676   jresult = new Dali::Animation((const Dali::Animation &)result);
61677
61678   //argout typemap for const std::string&
61679
61680   return jresult;
61681 }
61682
61683
61684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61685   void * jresult ;
61686   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61687   std::string *arg2 = 0 ;
61688   Dali::BaseHandle result;
61689
61690   arg1 = (Dali::Toolkit::Builder *)jarg1;
61691   if (!jarg2) {
61692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61693     return 0;
61694   }
61695   std::string arg2_str(jarg2);
61696   arg2 = &arg2_str;
61697   {
61698     try {
61699       result = (arg1)->Create((std::string const &)*arg2);
61700     } catch (std::out_of_range& e) {
61701       {
61702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61703       };
61704     } catch (std::exception& e) {
61705       {
61706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61707       };
61708     } catch (Dali::DaliException e) {
61709       {
61710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61711       };
61712     } catch (...) {
61713       {
61714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61715       };
61716     }
61717   }
61718
61719   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61720
61721   //argout typemap for const std::string&
61722
61723   return jresult;
61724 }
61725
61726
61727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61728   void * jresult ;
61729   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61730   std::string *arg2 = 0 ;
61731   Dali::Property::Map *arg3 = 0 ;
61732   Dali::BaseHandle result;
61733
61734   arg1 = (Dali::Toolkit::Builder *)jarg1;
61735   if (!jarg2) {
61736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61737     return 0;
61738   }
61739   std::string arg2_str(jarg2);
61740   arg2 = &arg2_str;
61741   arg3 = (Dali::Property::Map *)jarg3;
61742   if (!arg3) {
61743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61744     return 0;
61745   }
61746   {
61747     try {
61748       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61749     } catch (std::out_of_range& e) {
61750       {
61751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61752       };
61753     } catch (std::exception& e) {
61754       {
61755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61756       };
61757     } catch (Dali::DaliException e) {
61758       {
61759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61760       };
61761     } catch (...) {
61762       {
61763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61764       };
61765     }
61766   }
61767
61768   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61769
61770   //argout typemap for const std::string&
61771
61772   return jresult;
61773 }
61774
61775
61776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61777   void * jresult ;
61778   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61779   std::string *arg2 = 0 ;
61780   Dali::BaseHandle result;
61781
61782   arg1 = (Dali::Toolkit::Builder *)jarg1;
61783   if (!jarg2) {
61784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61785     return 0;
61786   }
61787   std::string arg2_str(jarg2);
61788   arg2 = &arg2_str;
61789   {
61790     try {
61791       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61792     } catch (std::out_of_range& e) {
61793       {
61794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61795       };
61796     } catch (std::exception& e) {
61797       {
61798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61799       };
61800     } catch (Dali::DaliException e) {
61801       {
61802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61803       };
61804     } catch (...) {
61805       {
61806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61807       };
61808     }
61809   }
61810
61811   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61812
61813   //argout typemap for const std::string&
61814
61815   return jresult;
61816 }
61817
61818
61819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61820   unsigned int jresult ;
61821   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61822   std::string *arg2 = 0 ;
61823   Dali::Handle *arg3 = 0 ;
61824   bool result;
61825
61826   arg1 = (Dali::Toolkit::Builder *)jarg1;
61827   if (!jarg2) {
61828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61829     return 0;
61830   }
61831   std::string arg2_str(jarg2);
61832   arg2 = &arg2_str;
61833   arg3 = (Dali::Handle *)jarg3;
61834   if (!arg3) {
61835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61836     return 0;
61837   }
61838   {
61839     try {
61840       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61841     } catch (std::out_of_range& e) {
61842       {
61843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61844       };
61845     } catch (std::exception& e) {
61846       {
61847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61848       };
61849     } catch (Dali::DaliException e) {
61850       {
61851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61852       };
61853     } catch (...) {
61854       {
61855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61856       };
61857     }
61858   }
61859
61860   jresult = result;
61861
61862   //argout typemap for const std::string&
61863
61864   return jresult;
61865 }
61866
61867
61868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61869   unsigned int jresult ;
61870   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61871   Dali::Handle *arg2 = 0 ;
61872   std::string *arg3 = 0 ;
61873   bool result;
61874
61875   arg1 = (Dali::Toolkit::Builder *)jarg1;
61876   arg2 = (Dali::Handle *)jarg2;
61877   if (!arg2) {
61878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61879     return 0;
61880   }
61881   if (!jarg3) {
61882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61883     return 0;
61884   }
61885   std::string arg3_str(jarg3);
61886   arg3 = &arg3_str;
61887   {
61888     try {
61889       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61890     } catch (std::out_of_range& e) {
61891       {
61892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61893       };
61894     } catch (std::exception& e) {
61895       {
61896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61897       };
61898     } catch (Dali::DaliException e) {
61899       {
61900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61901       };
61902     } catch (...) {
61903       {
61904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61905       };
61906     }
61907   }
61908
61909   jresult = result;
61910
61911   //argout typemap for const std::string&
61912
61913   return jresult;
61914 }
61915
61916
61917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61918   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61919   Dali::Actor arg2 ;
61920   Dali::Actor *argp2 ;
61921
61922   arg1 = (Dali::Toolkit::Builder *)jarg1;
61923   argp2 = (Dali::Actor *)jarg2;
61924   if (!argp2) {
61925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61926     return ;
61927   }
61928   arg2 = *argp2;
61929   {
61930     try {
61931       (arg1)->AddActors(arg2);
61932     } catch (std::out_of_range& e) {
61933       {
61934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61935       };
61936     } catch (std::exception& e) {
61937       {
61938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61939       };
61940     } catch (Dali::DaliException e) {
61941       {
61942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61943       };
61944     } catch (...) {
61945       {
61946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61947       };
61948     }
61949   }
61950
61951 }
61952
61953
61954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61955   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61956   std::string *arg2 = 0 ;
61957   Dali::Actor arg3 ;
61958   Dali::Actor *argp3 ;
61959
61960   arg1 = (Dali::Toolkit::Builder *)jarg1;
61961   if (!jarg2) {
61962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61963     return ;
61964   }
61965   std::string arg2_str(jarg2);
61966   arg2 = &arg2_str;
61967   argp3 = (Dali::Actor *)jarg3;
61968   if (!argp3) {
61969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61970     return ;
61971   }
61972   arg3 = *argp3;
61973   {
61974     try {
61975       (arg1)->AddActors((std::string const &)*arg2,arg3);
61976     } catch (std::out_of_range& e) {
61977       {
61978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61979       };
61980     } catch (std::exception& e) {
61981       {
61982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61983       };
61984     } catch (Dali::DaliException e) {
61985       {
61986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61987       };
61988     } catch (...) {
61989       {
61990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61991       };
61992     }
61993   }
61994
61995
61996   //argout typemap for const std::string&
61997
61998 }
61999
62000
62001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62002   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62003   std::string *arg2 = 0 ;
62004
62005   arg1 = (Dali::Toolkit::Builder *)jarg1;
62006   if (!jarg2) {
62007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62008     return ;
62009   }
62010   std::string arg2_str(jarg2);
62011   arg2 = &arg2_str;
62012   {
62013     try {
62014       (arg1)->CreateRenderTask((std::string const &)*arg2);
62015     } catch (std::out_of_range& e) {
62016       {
62017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62018       };
62019     } catch (std::exception& e) {
62020       {
62021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62022       };
62023     } catch (Dali::DaliException e) {
62024       {
62025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62026       };
62027     } catch (...) {
62028       {
62029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62030       };
62031     }
62032   }
62033
62034
62035   //argout typemap for const std::string&
62036
62037 }
62038
62039
62040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62041   void * jresult ;
62042   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62043   std::string *arg2 = 0 ;
62044   Dali::FrameBufferImage result;
62045
62046   arg1 = (Dali::Toolkit::Builder *)jarg1;
62047   if (!jarg2) {
62048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62049     return 0;
62050   }
62051   std::string arg2_str(jarg2);
62052   arg2 = &arg2_str;
62053   {
62054     try {
62055       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62056     } catch (std::out_of_range& e) {
62057       {
62058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62059       };
62060     } catch (std::exception& e) {
62061       {
62062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62063       };
62064     } catch (Dali::DaliException e) {
62065       {
62066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62067       };
62068     } catch (...) {
62069       {
62070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62071       };
62072     }
62073   }
62074
62075   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62076
62077   //argout typemap for const std::string&
62078
62079   return jresult;
62080 }
62081
62082
62083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62084   void * jresult ;
62085   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62086   std::string *arg2 = 0 ;
62087   Dali::Path result;
62088
62089   arg1 = (Dali::Toolkit::Builder *)jarg1;
62090   if (!jarg2) {
62091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62092     return 0;
62093   }
62094   std::string arg2_str(jarg2);
62095   arg2 = &arg2_str;
62096   {
62097     try {
62098       result = (arg1)->GetPath((std::string const &)*arg2);
62099     } catch (std::out_of_range& e) {
62100       {
62101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62102       };
62103     } catch (std::exception& e) {
62104       {
62105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62106       };
62107     } catch (Dali::DaliException e) {
62108       {
62109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62110       };
62111     } catch (...) {
62112       {
62113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62114       };
62115     }
62116   }
62117
62118   jresult = new Dali::Path((const Dali::Path &)result);
62119
62120   //argout typemap for const std::string&
62121
62122   return jresult;
62123 }
62124
62125
62126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62127   void * jresult ;
62128   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62129   std::string *arg2 = 0 ;
62130   Dali::PathConstrainer result;
62131
62132   arg1 = (Dali::Toolkit::Builder *)jarg1;
62133   if (!jarg2) {
62134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62135     return 0;
62136   }
62137   std::string arg2_str(jarg2);
62138   arg2 = &arg2_str;
62139   {
62140     try {
62141       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62142     } catch (std::out_of_range& e) {
62143       {
62144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62145       };
62146     } catch (std::exception& e) {
62147       {
62148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62149       };
62150     } catch (Dali::DaliException e) {
62151       {
62152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62153       };
62154     } catch (...) {
62155       {
62156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62157       };
62158     }
62159   }
62160
62161   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62162
62163   //argout typemap for const std::string&
62164
62165   return jresult;
62166 }
62167
62168
62169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62170   void * jresult ;
62171   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62172   std::string *arg2 = 0 ;
62173   Dali::LinearConstrainer result;
62174
62175   arg1 = (Dali::Toolkit::Builder *)jarg1;
62176   if (!jarg2) {
62177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62178     return 0;
62179   }
62180   std::string arg2_str(jarg2);
62181   arg2 = &arg2_str;
62182   {
62183     try {
62184       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62185     } catch (std::out_of_range& e) {
62186       {
62187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62188       };
62189     } catch (std::exception& e) {
62190       {
62191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62192       };
62193     } catch (Dali::DaliException e) {
62194       {
62195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62196       };
62197     } catch (...) {
62198       {
62199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62200       };
62201     }
62202   }
62203
62204   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62205
62206   //argout typemap for const std::string&
62207
62208   return jresult;
62209 }
62210
62211
62212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62213   void * jresult ;
62214   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62215   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62216
62217   arg1 = (Dali::Toolkit::Builder *)jarg1;
62218   {
62219     try {
62220       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62221     } catch (std::out_of_range& e) {
62222       {
62223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62224       };
62225     } catch (std::exception& e) {
62226       {
62227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62228       };
62229     } catch (Dali::DaliException e) {
62230       {
62231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62232       };
62233     } catch (...) {
62234       {
62235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62236       };
62237     }
62238   }
62239
62240   jresult = (void *)result;
62241   return jresult;
62242 }
62243
62244
62245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62246   void * jresult ;
62247   Dali::Toolkit::TransitionData *result = 0 ;
62248
62249   {
62250     try {
62251       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62252     } catch (std::out_of_range& e) {
62253       {
62254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62255       };
62256     } catch (std::exception& e) {
62257       {
62258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62259       };
62260     } catch (Dali::DaliException e) {
62261       {
62262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62263       };
62264     } catch (...) {
62265       {
62266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62267       };
62268     }
62269   }
62270
62271   jresult = (void *)result;
62272   return jresult;
62273 }
62274
62275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62276   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62277
62278   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62279   {
62280     try {
62281       delete arg1;
62282     } catch (std::out_of_range& e) {
62283       {
62284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62285       };
62286     } catch (std::exception& e) {
62287       {
62288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62289       };
62290     } catch (Dali::DaliException e) {
62291       {
62292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62293       };
62294     } catch (...) {
62295       {
62296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62297       };
62298     }
62299   }
62300
62301 }
62302
62303
62304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62305   void * jresult ;
62306   Dali::Property::Map *arg1 = 0 ;
62307   Dali::Toolkit::TransitionData result;
62308
62309   arg1 = (Dali::Property::Map *)jarg1;
62310   if (!arg1) {
62311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62312     return 0;
62313   }
62314   {
62315     try {
62316       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
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 = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62337   return jresult;
62338 }
62339
62340
62341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62342   void * jresult ;
62343   Dali::Property::Array *arg1 = 0 ;
62344   Dali::Toolkit::TransitionData result;
62345
62346   arg1 = (Dali::Property::Array *)jarg1;
62347   if (!arg1) {
62348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62349     return 0;
62350   }
62351   {
62352     try {
62353       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62354     } catch (std::out_of_range& e) {
62355       {
62356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62357       };
62358     } catch (std::exception& e) {
62359       {
62360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62361       };
62362     } catch (Dali::DaliException e) {
62363       {
62364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62365       };
62366     } catch (...) {
62367       {
62368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62369       };
62370     }
62371   }
62372
62373   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62374   return jresult;
62375 }
62376
62377
62378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62379   void * jresult ;
62380   Dali::BaseHandle arg1 ;
62381   Dali::BaseHandle *argp1 ;
62382   Dali::Toolkit::TransitionData result;
62383
62384   argp1 = (Dali::BaseHandle *)jarg1;
62385   if (!argp1) {
62386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62387     return 0;
62388   }
62389   arg1 = *argp1;
62390   {
62391     try {
62392       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62393     } catch (std::out_of_range& e) {
62394       {
62395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62396       };
62397     } catch (std::exception& e) {
62398       {
62399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62400       };
62401     } catch (Dali::DaliException e) {
62402       {
62403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62404       };
62405     } catch (...) {
62406       {
62407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62408       };
62409     }
62410   }
62411
62412   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62413   return jresult;
62414 }
62415
62416
62417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62418   void * jresult ;
62419   Dali::Toolkit::TransitionData *arg1 = 0 ;
62420   Dali::Toolkit::TransitionData *result = 0 ;
62421
62422   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62423   if (!arg1) {
62424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62425     return 0;
62426   }
62427   {
62428     try {
62429       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62430     } catch (std::out_of_range& e) {
62431       {
62432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62433       };
62434     } catch (std::exception& e) {
62435       {
62436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62437       };
62438     } catch (Dali::DaliException e) {
62439       {
62440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62441       };
62442     } catch (...) {
62443       {
62444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62445       };
62446     }
62447   }
62448
62449   jresult = (void *)result;
62450   return jresult;
62451 }
62452
62453
62454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62455   void * jresult ;
62456   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62457   Dali::Toolkit::TransitionData *arg2 = 0 ;
62458   Dali::Toolkit::TransitionData *result = 0 ;
62459
62460   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62461   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62462   if (!arg2) {
62463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62464     return 0;
62465   }
62466   {
62467     try {
62468       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62469     } catch (std::out_of_range& e) {
62470       {
62471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62472       };
62473     } catch (std::exception& e) {
62474       {
62475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62476       };
62477     } catch (Dali::DaliException e) {
62478       {
62479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62480       };
62481     } catch (...) {
62482       {
62483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62484       };
62485     }
62486   }
62487
62488   jresult = (void *)result;
62489   return jresult;
62490 }
62491
62492
62493 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62494   unsigned long jresult ;
62495   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62496   size_t result;
62497
62498   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62499   {
62500     try {
62501       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62502     } catch (std::out_of_range& e) {
62503       {
62504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62505       };
62506     } catch (std::exception& e) {
62507       {
62508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62509       };
62510     } catch (Dali::DaliException e) {
62511       {
62512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62513       };
62514     } catch (...) {
62515       {
62516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62517       };
62518     }
62519   }
62520
62521   jresult = (unsigned long)result;
62522   return jresult;
62523 }
62524
62525
62526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62527   void * jresult ;
62528   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62529   size_t arg2 ;
62530   Dali::Property::Map result;
62531
62532   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62533   arg2 = (size_t)jarg2;
62534   {
62535     try {
62536       result = (arg1)->GetAnimatorAt(arg2);
62537     } catch (std::out_of_range& e) {
62538       {
62539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62540       };
62541     } catch (std::exception& e) {
62542       {
62543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62544       };
62545     } catch (Dali::DaliException e) {
62546       {
62547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62548       };
62549     } catch (...) {
62550       {
62551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62552       };
62553     }
62554   }
62555
62556   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62557   return jresult;
62558 }
62559
62560
62561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62562   int jresult ;
62563   int result;
62564
62565   {
62566     try {
62567       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62568     } catch (std::out_of_range& e) {
62569       {
62570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62571       };
62572     } catch (std::exception& e) {
62573       {
62574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62575       };
62576     } catch (Dali::DaliException e) {
62577       {
62578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62579       };
62580     } catch (...) {
62581       {
62582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62583       };
62584     }
62585   }
62586
62587   jresult = (int)result;
62588   return jresult;
62589 }
62590
62591
62592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62593   int jresult ;
62594   int result;
62595
62596   {
62597     try {
62598       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62599     } catch (std::out_of_range& e) {
62600       {
62601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62602       };
62603     } catch (std::exception& e) {
62604       {
62605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62606       };
62607     } catch (Dali::DaliException e) {
62608       {
62609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62610       };
62611     } catch (...) {
62612       {
62613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62614       };
62615     }
62616   }
62617
62618   jresult = (int)result;
62619   return jresult;
62620 }
62621
62622
62623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62624   int jresult ;
62625   int result;
62626
62627   {
62628     try {
62629       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62630     } catch (std::out_of_range& e) {
62631       {
62632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62633       };
62634     } catch (std::exception& e) {
62635       {
62636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62637       };
62638     } catch (Dali::DaliException e) {
62639       {
62640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62641       };
62642     } catch (...) {
62643       {
62644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62645       };
62646     }
62647   }
62648
62649   jresult = (int)result;
62650   return jresult;
62651 }
62652
62653
62654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62655   int jresult ;
62656   int result;
62657
62658   {
62659     try {
62660       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
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 = (int)result;
62681   return jresult;
62682 }
62683
62684
62685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62686   int jresult ;
62687   int result;
62688
62689   {
62690     try {
62691       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62692     } catch (std::out_of_range& e) {
62693       {
62694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62695       };
62696     } catch (std::exception& e) {
62697       {
62698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62699       };
62700     } catch (Dali::DaliException e) {
62701       {
62702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62703       };
62704     } catch (...) {
62705       {
62706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62707       };
62708     }
62709   }
62710
62711   jresult = (int)result;
62712   return jresult;
62713 }
62714
62715
62716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62717   int jresult ;
62718   int result;
62719
62720   {
62721     try {
62722       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62723     } catch (std::out_of_range& e) {
62724       {
62725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62726       };
62727     } catch (std::exception& e) {
62728       {
62729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62730       };
62731     } catch (Dali::DaliException e) {
62732       {
62733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62734       };
62735     } catch (...) {
62736       {
62737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62738       };
62739     }
62740   }
62741
62742   jresult = (int)result;
62743   return jresult;
62744 }
62745
62746
62747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62748   int jresult ;
62749   int result;
62750
62751   {
62752     try {
62753       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62754     } catch (std::out_of_range& e) {
62755       {
62756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62757       };
62758     } catch (std::exception& e) {
62759       {
62760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62761       };
62762     } catch (Dali::DaliException e) {
62763       {
62764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62765       };
62766     } catch (...) {
62767       {
62768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62769       };
62770     }
62771   }
62772
62773   jresult = (int)result;
62774   return jresult;
62775 }
62776
62777
62778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62779   int jresult ;
62780   int result;
62781
62782   {
62783     try {
62784       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62785     } catch (std::out_of_range& e) {
62786       {
62787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62788       };
62789     } catch (std::exception& e) {
62790       {
62791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62792       };
62793     } catch (Dali::DaliException e) {
62794       {
62795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62796       };
62797     } catch (...) {
62798       {
62799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62800       };
62801     }
62802   }
62803
62804   jresult = (int)result;
62805   return jresult;
62806 }
62807
62808
62809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62810   int jresult ;
62811   int result;
62812
62813   {
62814     try {
62815       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62816     } catch (std::out_of_range& e) {
62817       {
62818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62819       };
62820     } catch (std::exception& e) {
62821       {
62822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62823       };
62824     } catch (Dali::DaliException e) {
62825       {
62826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62827       };
62828     } catch (...) {
62829       {
62830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62831       };
62832     }
62833   }
62834
62835   jresult = (int)result;
62836   return jresult;
62837 }
62838
62839
62840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62841   int jresult ;
62842   int result;
62843
62844   {
62845     try {
62846       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62847     } catch (std::out_of_range& e) {
62848       {
62849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62850       };
62851     } catch (std::exception& e) {
62852       {
62853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62854       };
62855     } catch (Dali::DaliException e) {
62856       {
62857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62858       };
62859     } catch (...) {
62860       {
62861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62862       };
62863     }
62864   }
62865
62866   jresult = (int)result;
62867   return jresult;
62868 }
62869
62870
62871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62872   int jresult ;
62873   int result;
62874
62875   {
62876     try {
62877       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62878     } catch (std::out_of_range& e) {
62879       {
62880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62881       };
62882     } catch (std::exception& e) {
62883       {
62884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62885       };
62886     } catch (Dali::DaliException e) {
62887       {
62888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62889       };
62890     } catch (...) {
62891       {
62892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62893       };
62894     }
62895   }
62896
62897   jresult = (int)result;
62898   return jresult;
62899 }
62900
62901
62902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62903   int jresult ;
62904   int result;
62905
62906   {
62907     try {
62908       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62909     } catch (std::out_of_range& e) {
62910       {
62911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62912       };
62913     } catch (std::exception& e) {
62914       {
62915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62916       };
62917     } catch (Dali::DaliException e) {
62918       {
62919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62920       };
62921     } catch (...) {
62922       {
62923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62924       };
62925     }
62926   }
62927
62928   jresult = (int)result;
62929   return jresult;
62930 }
62931
62932
62933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62934   int jresult ;
62935   int result;
62936
62937   {
62938     try {
62939       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62940     } catch (std::out_of_range& e) {
62941       {
62942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62943       };
62944     } catch (std::exception& e) {
62945       {
62946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62947       };
62948     } catch (Dali::DaliException e) {
62949       {
62950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62951       };
62952     } catch (...) {
62953       {
62954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62955       };
62956     }
62957   }
62958
62959   jresult = (int)result;
62960   return jresult;
62961 }
62962
62963
62964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62965   int jresult ;
62966   int result;
62967
62968   {
62969     try {
62970       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62971     } catch (std::out_of_range& e) {
62972       {
62973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62974       };
62975     } catch (std::exception& e) {
62976       {
62977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62978       };
62979     } catch (Dali::DaliException e) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62982       };
62983     } catch (...) {
62984       {
62985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62986       };
62987     }
62988   }
62989
62990   jresult = (int)result;
62991   return jresult;
62992 }
62993
62994
62995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62996   void * jresult ;
62997   Dali::Toolkit::Control result;
62998
62999   {
63000     try {
63001       result = Dali::Toolkit::Internal::Control::New();
63002     } catch (std::out_of_range& e) {
63003       {
63004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63005       };
63006     } catch (std::exception& e) {
63007       {
63008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63009       };
63010     } catch (Dali::DaliException e) {
63011       {
63012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63013       };
63014     } catch (...) {
63015       {
63016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63017       };
63018     }
63019   }
63020
63021   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63022   return jresult;
63023 }
63024
63025
63026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63028   std::string *arg2 = 0 ;
63029
63030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63031   if (!jarg2) {
63032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63033     return ;
63034   }
63035   std::string arg2_str(jarg2);
63036   arg2 = &arg2_str;
63037   {
63038     try {
63039       (arg1)->SetStyleName((std::string const &)*arg2);
63040     } catch (std::out_of_range& e) {
63041       {
63042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63043       };
63044     } catch (std::exception& e) {
63045       {
63046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63047       };
63048     } catch (Dali::DaliException e) {
63049       {
63050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63051       };
63052     } catch (...) {
63053       {
63054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63055       };
63056     }
63057   }
63058
63059
63060   //argout typemap for const std::string&
63061
63062 }
63063
63064
63065 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63066   char * jresult ;
63067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63068   std::string *result = 0 ;
63069
63070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63071   {
63072     try {
63073       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63074     } catch (std::out_of_range& e) {
63075       {
63076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63077       };
63078     } catch (std::exception& e) {
63079       {
63080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63081       };
63082     } catch (Dali::DaliException e) {
63083       {
63084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63085       };
63086     } catch (...) {
63087       {
63088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63089       };
63090     }
63091   }
63092
63093   jresult = SWIG_csharp_string_callback(result->c_str());
63094   return jresult;
63095 }
63096
63097
63098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63099   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63100   Dali::Vector4 *arg2 = 0 ;
63101
63102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63103   arg2 = (Dali::Vector4 *)jarg2;
63104   if (!arg2) {
63105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63106     return ;
63107   }
63108   {
63109     try {
63110       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63111     } catch (std::out_of_range& e) {
63112       {
63113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63114       };
63115     } catch (std::exception& e) {
63116       {
63117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63118       };
63119     } catch (Dali::DaliException e) {
63120       {
63121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63122       };
63123     } catch (...) {
63124       {
63125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63126       };
63127     }
63128   }
63129
63130 }
63131
63132
63133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63134   void * jresult ;
63135   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63136   Dali::Vector4 result;
63137
63138   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63139   {
63140     try {
63141       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63142     } catch (std::out_of_range& e) {
63143       {
63144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63145       };
63146     } catch (std::exception& e) {
63147       {
63148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63149       };
63150     } catch (Dali::DaliException e) {
63151       {
63152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63153       };
63154     } catch (...) {
63155       {
63156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63157       };
63158     }
63159   }
63160
63161   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63162   return jresult;
63163 }
63164
63165
63166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63168   Dali::Image arg2 ;
63169   Dali::Image *argp2 ;
63170
63171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63172   argp2 = (Dali::Image *)jarg2;
63173   if (!argp2) {
63174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63175     return ;
63176   }
63177   arg2 = *argp2;
63178   {
63179     try {
63180       (arg1)->SetBackgroundImage(arg2);
63181     } catch (std::out_of_range& e) {
63182       {
63183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63184       };
63185     } catch (std::exception& e) {
63186       {
63187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63188       };
63189     } catch (Dali::DaliException e) {
63190       {
63191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63192       };
63193     } catch (...) {
63194       {
63195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63196       };
63197     }
63198   }
63199
63200 }
63201
63202
63203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63205   Dali::Property::Map *arg2 = 0 ;
63206
63207   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63208   arg2 = (Dali::Property::Map *)jarg2;
63209   if (!arg2) {
63210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63211     return ;
63212   }
63213   {
63214     try {
63215       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63216     } catch (std::out_of_range& e) {
63217       {
63218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63219       };
63220     } catch (std::exception& e) {
63221       {
63222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63223       };
63224     } catch (Dali::DaliException e) {
63225       {
63226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63227       };
63228     } catch (...) {
63229       {
63230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63231       };
63232     }
63233   }
63234
63235 }
63236
63237
63238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63240
63241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63242   {
63243     try {
63244       (arg1)->ClearBackground();
63245     } catch (std::out_of_range& e) {
63246       {
63247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63248       };
63249     } catch (std::exception& e) {
63250       {
63251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63252       };
63253     } catch (Dali::DaliException e) {
63254       {
63255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63256       };
63257     } catch (...) {
63258       {
63259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63260       };
63261     }
63262   }
63263
63264 }
63265
63266
63267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63269   Dali::Gesture::Type arg2 ;
63270
63271   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63272   arg2 = (Dali::Gesture::Type)jarg2;
63273   {
63274     try {
63275       (arg1)->EnableGestureDetection(arg2);
63276     } catch (std::out_of_range& e) {
63277       {
63278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63279       };
63280     } catch (std::exception& e) {
63281       {
63282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63283       };
63284     } catch (Dali::DaliException e) {
63285       {
63286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63287       };
63288     } catch (...) {
63289       {
63290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63291       };
63292     }
63293   }
63294
63295 }
63296
63297
63298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63300   Dali::Gesture::Type arg2 ;
63301
63302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63303   arg2 = (Dali::Gesture::Type)jarg2;
63304   {
63305     try {
63306       (arg1)->DisableGestureDetection(arg2);
63307     } catch (std::out_of_range& e) {
63308       {
63309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63310       };
63311     } catch (std::exception& e) {
63312       {
63313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63314       };
63315     } catch (Dali::DaliException e) {
63316       {
63317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63318       };
63319     } catch (...) {
63320       {
63321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63322       };
63323     }
63324   }
63325
63326 }
63327
63328
63329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63330   void * jresult ;
63331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63332   Dali::PinchGestureDetector result;
63333
63334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63335   {
63336     try {
63337       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63338     } catch (std::out_of_range& e) {
63339       {
63340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63341       };
63342     } catch (std::exception& e) {
63343       {
63344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63345       };
63346     } catch (Dali::DaliException e) {
63347       {
63348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63349       };
63350     } catch (...) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63353       };
63354     }
63355   }
63356
63357   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63358   return jresult;
63359 }
63360
63361
63362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63363   void * jresult ;
63364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63365   Dali::PanGestureDetector result;
63366
63367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63368   {
63369     try {
63370       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63371     } catch (std::out_of_range& e) {
63372       {
63373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63374       };
63375     } catch (std::exception& e) {
63376       {
63377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63378       };
63379     } catch (Dali::DaliException e) {
63380       {
63381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63382       };
63383     } catch (...) {
63384       {
63385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63386       };
63387     }
63388   }
63389
63390   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63391   return jresult;
63392 }
63393
63394
63395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63396   void * jresult ;
63397   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63398   Dali::TapGestureDetector result;
63399
63400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63401   {
63402     try {
63403       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63404     } catch (std::out_of_range& e) {
63405       {
63406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63407       };
63408     } catch (std::exception& e) {
63409       {
63410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63411       };
63412     } catch (Dali::DaliException e) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63415       };
63416     } catch (...) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63419       };
63420     }
63421   }
63422
63423   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63424   return jresult;
63425 }
63426
63427
63428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63429   void * jresult ;
63430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63431   Dali::LongPressGestureDetector result;
63432
63433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63434   {
63435     try {
63436       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63437     } catch (std::out_of_range& e) {
63438       {
63439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63440       };
63441     } catch (std::exception& e) {
63442       {
63443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63444       };
63445     } catch (Dali::DaliException e) {
63446       {
63447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63448       };
63449     } catch (...) {
63450       {
63451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63452       };
63453     }
63454   }
63455
63456   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63457   return jresult;
63458 }
63459
63460
63461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63463   bool arg2 ;
63464
63465   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63466   arg2 = jarg2 ? true : false;
63467   {
63468     try {
63469       (arg1)->SetKeyboardNavigationSupport(arg2);
63470     } catch (std::out_of_range& e) {
63471       {
63472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63473       };
63474     } catch (std::exception& e) {
63475       {
63476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63477       };
63478     } catch (Dali::DaliException e) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63481       };
63482     } catch (...) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63485       };
63486     }
63487   }
63488
63489 }
63490
63491
63492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63493   unsigned int jresult ;
63494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63495   bool result;
63496
63497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63498   {
63499     try {
63500       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63501     } catch (std::out_of_range& e) {
63502       {
63503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63504       };
63505     } catch (std::exception& e) {
63506       {
63507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63508       };
63509     } catch (Dali::DaliException e) {
63510       {
63511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63512       };
63513     } catch (...) {
63514       {
63515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63516       };
63517     }
63518   }
63519
63520   jresult = result;
63521   return jresult;
63522 }
63523
63524
63525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63527
63528   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63529   {
63530     try {
63531       (arg1)->SetKeyInputFocus();
63532     } catch (std::out_of_range& e) {
63533       {
63534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63535       };
63536     } catch (std::exception& e) {
63537       {
63538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63539       };
63540     } catch (Dali::DaliException e) {
63541       {
63542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63543       };
63544     } catch (...) {
63545       {
63546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63547       };
63548     }
63549   }
63550
63551 }
63552
63553
63554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63555   unsigned int jresult ;
63556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63557   bool result;
63558
63559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63560   {
63561     try {
63562       result = (bool)(arg1)->HasKeyInputFocus();
63563     } catch (std::out_of_range& e) {
63564       {
63565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63566       };
63567     } catch (std::exception& e) {
63568       {
63569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63570       };
63571     } catch (Dali::DaliException e) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63574       };
63575     } catch (...) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63578       };
63579     }
63580   }
63581
63582   jresult = result;
63583   return jresult;
63584 }
63585
63586
63587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63589
63590   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63591   {
63592     try {
63593       (arg1)->ClearKeyInputFocus();
63594     } catch (std::out_of_range& e) {
63595       {
63596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63597       };
63598     } catch (std::exception& e) {
63599       {
63600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63601       };
63602     } catch (Dali::DaliException e) {
63603       {
63604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63605       };
63606     } catch (...) {
63607       {
63608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63609       };
63610     }
63611   }
63612
63613 }
63614
63615
63616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63618   bool arg2 ;
63619
63620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63621   arg2 = jarg2 ? true : false;
63622   {
63623     try {
63624       (arg1)->SetAsKeyboardFocusGroup(arg2);
63625     } catch (std::out_of_range& e) {
63626       {
63627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63628       };
63629     } catch (std::exception& e) {
63630       {
63631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63632       };
63633     } catch (Dali::DaliException e) {
63634       {
63635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63636       };
63637     } catch (...) {
63638       {
63639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63640       };
63641     }
63642   }
63643
63644 }
63645
63646
63647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63648   unsigned int jresult ;
63649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63650   bool result;
63651
63652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63653   {
63654     try {
63655       result = (bool)(arg1)->IsKeyboardFocusGroup();
63656     } catch (std::out_of_range& e) {
63657       {
63658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63659       };
63660     } catch (std::exception& e) {
63661       {
63662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63663       };
63664     } catch (Dali::DaliException e) {
63665       {
63666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63667       };
63668     } catch (...) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63671       };
63672     }
63673   }
63674
63675   jresult = result;
63676   return jresult;
63677 }
63678
63679
63680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63681   void * jresult ;
63682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63683   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63684
63685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63686   {
63687     try {
63688       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63689     } catch (std::out_of_range& e) {
63690       {
63691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63692       };
63693     } catch (std::exception& e) {
63694       {
63695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63696       };
63697     } catch (Dali::DaliException e) {
63698       {
63699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63700       };
63701     } catch (...) {
63702       {
63703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63704       };
63705     }
63706   }
63707
63708   jresult = (void *)result;
63709   return jresult;
63710 }
63711
63712
63713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63714   void * jresult ;
63715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63716   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63717
63718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63719   {
63720     try {
63721       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63722     } catch (std::out_of_range& e) {
63723       {
63724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63725       };
63726     } catch (std::exception& e) {
63727       {
63728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63729       };
63730     } catch (Dali::DaliException e) {
63731       {
63732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63733       };
63734     } catch (...) {
63735       {
63736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63737       };
63738     }
63739   }
63740
63741   jresult = (void *)result;
63742   return jresult;
63743 }
63744
63745
63746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63747   void * jresult ;
63748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63749   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63750
63751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63752   {
63753     try {
63754       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63755     } catch (std::out_of_range& e) {
63756       {
63757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63758       };
63759     } catch (std::exception& e) {
63760       {
63761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63762       };
63763     } catch (Dali::DaliException e) {
63764       {
63765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63766       };
63767     } catch (...) {
63768       {
63769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63770       };
63771     }
63772   }
63773
63774   jresult = (void *)result;
63775   return jresult;
63776 }
63777
63778
63779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63781   int arg2 ;
63782   SwigDirector_ViewImpl *darg = 0;
63783
63784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63785   arg2 = (int)jarg2;
63786   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63787   if(!darg) {
63788     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63789     return;
63790   }
63791   {
63792     try {
63793       if(darg) {
63794         (darg)->OnStageConnection(arg2);
63795       }
63796     } catch (std::out_of_range& e) {
63797       {
63798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63799       };
63800     } catch (std::exception& e) {
63801       {
63802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63803       };
63804     } catch (Dali::DaliException e) {
63805       {
63806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63807       };
63808     } catch (...) {
63809       {
63810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63811       };
63812     }
63813   }
63814
63815 }
63816
63817
63818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63819   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63820   int arg2 ;
63821   SwigDirector_ViewImpl *darg = 0;
63822
63823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63824   arg2 = (int)jarg2;
63825   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63826   if(!darg) {
63827     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63828     return;
63829   }
63830   {
63831     try {
63832       if(darg) {
63833         (darg)->OnStageConnectionSwigPublic(arg2);
63834       }
63835     } catch (std::out_of_range& e) {
63836       {
63837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63838       };
63839     } catch (std::exception& e) {
63840       {
63841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63842       };
63843     } catch (Dali::DaliException e) {
63844       {
63845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63846       };
63847     } catch (...) {
63848       {
63849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63850       };
63851     }
63852   }
63853
63854 }
63855
63856
63857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63859   SwigDirector_ViewImpl *darg = 0;
63860
63861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63862   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63863   if(!darg) {
63864     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63865     return;
63866   }
63867   {
63868     try {
63869       if(darg) {
63870         (darg)->OnStageDisconnection();
63871       }
63872     } catch (std::out_of_range& e) {
63873       {
63874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63875       };
63876     } catch (std::exception& e) {
63877       {
63878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63879       };
63880     } catch (Dali::DaliException e) {
63881       {
63882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63883       };
63884     } catch (...) {
63885       {
63886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63887       };
63888     }
63889   }
63890
63891 }
63892
63893
63894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63896   SwigDirector_ViewImpl *darg = 0;
63897
63898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63899   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63900   if(!darg) {
63901     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63902     return;
63903   }
63904   {
63905     try {
63906       if(darg) {
63907         (darg)->OnStageDisconnectionSwigPublic();
63908       }
63909     } catch (std::out_of_range& e) {
63910       {
63911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63912       };
63913     } catch (std::exception& e) {
63914       {
63915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63916       };
63917     } catch (Dali::DaliException e) {
63918       {
63919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63920       };
63921     } catch (...) {
63922       {
63923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63924       };
63925     }
63926   }
63927
63928 }
63929
63930
63931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63932   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63933   Dali::Actor *arg2 = 0 ;
63934   SwigDirector_ViewImpl *darg = 0;
63935
63936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63937   arg2 = (Dali::Actor *)jarg2;
63938   if (!arg2) {
63939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63940     return ;
63941   }
63942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63943   if(!darg) {
63944     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63945     return;
63946   }
63947   {
63948     try {
63949       if(darg) {
63950         (darg)->OnChildAdd(*arg2);
63951       }
63952     } catch (std::out_of_range& e) {
63953       {
63954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63955       };
63956     } catch (std::exception& e) {
63957       {
63958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63959       };
63960     } catch (Dali::DaliException e) {
63961       {
63962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63963       };
63964     } catch (...) {
63965       {
63966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63967       };
63968     }
63969   }
63970
63971 }
63972
63973
63974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63976   Dali::Actor *arg2 = 0 ;
63977   SwigDirector_ViewImpl *darg = 0;
63978
63979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63980   arg2 = (Dali::Actor *)jarg2;
63981   if (!arg2) {
63982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63983     return ;
63984   }
63985   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63986   if(!darg) {
63987     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63988     return;
63989   }
63990   {
63991     try {
63992       if(darg) {
63993           (darg)->OnChildAddSwigPublic(*arg2);
63994       }
63995     } catch (std::out_of_range& e) {
63996       {
63997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63998       };
63999     } catch (std::exception& e) {
64000       {
64001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64002       };
64003     } catch (Dali::DaliException e) {
64004       {
64005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64006       };
64007     } catch (...) {
64008       {
64009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64010       };
64011     }
64012   }
64013
64014 }
64015
64016
64017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64018   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64019   Dali::Actor *arg2 = 0 ;
64020   SwigDirector_ViewImpl *darg = 0;
64021
64022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64023   arg2 = (Dali::Actor *)jarg2;
64024   if (!arg2) {
64025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64026     return ;
64027   }
64028   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64029   if(!darg) {
64030     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64031     return;
64032   }
64033   {
64034     try {
64035       if(darg) {
64036         (darg)->OnChildRemove(*arg2);
64037       }
64038     } catch (std::out_of_range& e) {
64039       {
64040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64041       };
64042     } catch (std::exception& e) {
64043       {
64044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64045       };
64046     } catch (Dali::DaliException e) {
64047       {
64048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64049       };
64050     } catch (...) {
64051       {
64052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64053       };
64054     }
64055   }
64056
64057 }
64058
64059
64060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64062   Dali::Actor *arg2 = 0 ;
64063   SwigDirector_ViewImpl *darg = 0;
64064
64065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64066   arg2 = (Dali::Actor *)jarg2;
64067   if (!arg2) {
64068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64069     return ;
64070   }
64071   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64072   if(!darg) {
64073     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64074     return;
64075   }
64076   {
64077     try {
64078       if(darg) {
64079         (darg)->OnChildRemoveSwigPublic(*arg2);
64080       }
64081     } catch (std::out_of_range& e) {
64082       {
64083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64084       };
64085     } catch (std::exception& e) {
64086       {
64087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64088       };
64089     } catch (Dali::DaliException e) {
64090       {
64091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64092       };
64093     } catch (...) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64096       };
64097     }
64098   }
64099
64100 }
64101
64102
64103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64104   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64105   Dali::Property::Index arg2 ;
64106   Dali::Property::Value arg3 ;
64107   Dali::Property::Value *argp3 ;
64108   SwigDirector_ViewImpl *darg = 0;
64109
64110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64111   arg2 = (Dali::Property::Index)jarg2;
64112   argp3 = (Dali::Property::Value *)jarg3;
64113   if (!argp3) {
64114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64115     return ;
64116   }
64117   arg3 = *argp3;
64118   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64119   if (!darg) {
64120     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64121     return;
64122   }
64123   {
64124     try {
64125       (darg)->OnPropertySet(arg2,arg3);
64126     } catch (std::out_of_range& e) {
64127       {
64128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64129       };
64130     } catch (std::exception& e) {
64131       {
64132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64133       };
64134     } catch (Dali::DaliException e) {
64135       {
64136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64137       };
64138     } catch (...) {
64139       {
64140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64141       };
64142     }
64143   }
64144
64145 }
64146
64147
64148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64150   Dali::Property::Index arg2 ;
64151   Dali::Property::Value arg3 ;
64152   Dali::Property::Value *argp3 ;
64153   SwigDirector_ViewImpl *darg = 0;
64154
64155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64156   arg2 = (Dali::Property::Index)jarg2;
64157   argp3 = (Dali::Property::Value *)jarg3;
64158   if (!argp3) {
64159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64160     return ;
64161   }
64162   arg3 = *argp3;
64163   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64164   if (!darg) {
64165     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64166     return;
64167   }
64168   {
64169     try {
64170       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64171     } catch (std::out_of_range& e) {
64172       {
64173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64174       };
64175     } catch (std::exception& e) {
64176       {
64177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64178       };
64179     } catch (Dali::DaliException e) {
64180       {
64181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64182       };
64183     } catch (...) {
64184       {
64185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64186       };
64187     }
64188   }
64189
64190 }
64191
64192
64193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64195   Dali::Vector3 *arg2 = 0 ;
64196   SwigDirector_ViewImpl *darg = 0;
64197
64198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64199   arg2 = (Dali::Vector3 *)jarg2;
64200   if (!arg2) {
64201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64202     return ;
64203   }
64204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64205   if (!darg) {
64206     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64207     return;
64208   }
64209   {
64210     try {
64211       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64212     } catch (std::out_of_range& e) {
64213       {
64214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64215       };
64216     } catch (std::exception& e) {
64217       {
64218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64219       };
64220     } catch (Dali::DaliException e) {
64221       {
64222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64223       };
64224     } catch (...) {
64225       {
64226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64227       };
64228     }
64229   }
64230
64231 }
64232
64233
64234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64235   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64236   Dali::Vector3 *arg2 = 0 ;
64237   SwigDirector_ViewImpl *darg = 0;
64238
64239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64240   arg2 = (Dali::Vector3 *)jarg2;
64241   if (!arg2) {
64242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64243     return ;
64244   }
64245   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64246   if (!darg) {
64247     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64248     return;
64249   }
64250   {
64251     try {
64252       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64253     } catch (std::out_of_range& e) {
64254       {
64255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64256       };
64257     } catch (std::exception& e) {
64258       {
64259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64260       };
64261     } catch (Dali::DaliException e) {
64262       {
64263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64264       };
64265     } catch (...) {
64266       {
64267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64268       };
64269     }
64270   }
64271
64272 }
64273
64274
64275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64277   Dali::Animation *arg2 = 0 ;
64278   Dali::Vector3 *arg3 = 0 ;
64279   SwigDirector_ViewImpl *darg = 0;
64280
64281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64282   arg2 = (Dali::Animation *)jarg2;
64283   if (!arg2) {
64284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64285     return ;
64286   }
64287   arg3 = (Dali::Vector3 *)jarg3;
64288   if (!arg3) {
64289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64290     return ;
64291   }
64292   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64293   if (!darg) {
64294     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64295     return;
64296   }
64297   {
64298     try {
64299       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64300     } catch (std::out_of_range& e) {
64301       {
64302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64303       };
64304     } catch (std::exception& e) {
64305       {
64306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64307       };
64308     } catch (Dali::DaliException e) {
64309       {
64310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64311       };
64312     } catch (...) {
64313       {
64314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64315       };
64316     }
64317   }
64318
64319 }
64320
64321
64322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64324   Dali::Animation *arg2 = 0 ;
64325   Dali::Vector3 *arg3 = 0 ;
64326   SwigDirector_ViewImpl *darg = 0;
64327
64328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64329   arg2 = (Dali::Animation *)jarg2;
64330   if (!arg2) {
64331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64332     return ;
64333   }
64334   arg3 = (Dali::Vector3 *)jarg3;
64335   if (!arg3) {
64336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64337     return ;
64338   }
64339   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64340   if (!darg) {
64341     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64342     return;
64343   }
64344   {
64345     try {
64346       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64347     } catch (std::out_of_range& e) {
64348       {
64349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64350       };
64351     } catch (std::exception& e) {
64352       {
64353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64354       };
64355     } catch (Dali::DaliException e) {
64356       {
64357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64358       };
64359     } catch (...) {
64360       {
64361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64362       };
64363     }
64364   }
64365
64366 }
64367
64368
64369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64370   unsigned int jresult ;
64371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64372   Dali::TouchEvent *arg2 = 0 ;
64373   SwigDirector_ViewImpl *darg = 0;
64374   bool result;
64375
64376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64377   arg2 = (Dali::TouchEvent *)jarg2;
64378   if (!arg2) {
64379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64380     return 0;
64381   }
64382   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64383   if (!darg) {
64384     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64385     return 0;
64386   }
64387   {
64388     try {
64389       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64390     } catch (std::out_of_range& e) {
64391       {
64392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64393       };
64394     } catch (std::exception& e) {
64395       {
64396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64397       };
64398     } catch (Dali::DaliException e) {
64399       {
64400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64401       };
64402     } catch (...) {
64403       {
64404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64405       };
64406     }
64407   }
64408
64409   jresult = result;
64410   return jresult;
64411 }
64412
64413
64414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64415   unsigned int jresult ;
64416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64417   Dali::TouchEvent *arg2 = 0 ;
64418   SwigDirector_ViewImpl *darg = 0;
64419   bool result;
64420
64421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64422   arg2 = (Dali::TouchEvent *)jarg2;
64423   if (!arg2) {
64424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64425     return 0;
64426   }
64427   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64428   if (!darg) {
64429     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64430     return 0;
64431   }
64432   {
64433     try {
64434       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64435     } catch (std::out_of_range& e) {
64436       {
64437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64438       };
64439     } catch (std::exception& e) {
64440       {
64441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64442       };
64443     } catch (Dali::DaliException e) {
64444       {
64445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64446       };
64447     } catch (...) {
64448       {
64449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64450       };
64451     }
64452   }
64453
64454   jresult = result;
64455   return jresult;
64456 }
64457
64458
64459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64460   unsigned int jresult ;
64461   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64462   Dali::HoverEvent *arg2 = 0 ;
64463   SwigDirector_ViewImpl *darg = 0;
64464   bool result;
64465
64466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64467   arg2 = (Dali::HoverEvent *)jarg2;
64468   if (!arg2) {
64469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64470     return 0;
64471   }
64472   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64473   if (!darg) {
64474     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64475     return 0;
64476   }
64477   {
64478     try {
64479       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64480     } catch (std::out_of_range& e) {
64481       {
64482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64483       };
64484     } catch (std::exception& e) {
64485       {
64486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64487       };
64488     } catch (Dali::DaliException e) {
64489       {
64490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64491       };
64492     } catch (...) {
64493       {
64494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64495       };
64496     }
64497   }
64498
64499   jresult = result;
64500   return jresult;
64501 }
64502
64503
64504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64505   unsigned int jresult ;
64506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64507   Dali::HoverEvent *arg2 = 0 ;
64508   SwigDirector_ViewImpl *darg = 0;
64509   bool result;
64510
64511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64512   arg2 = (Dali::HoverEvent *)jarg2;
64513   if (!arg2) {
64514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64515     return 0;
64516   }
64517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64518   if (!darg) {
64519     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64520     return 0;
64521   }
64522   {
64523     try {
64524       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64525     } catch (std::out_of_range& e) {
64526       {
64527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64528       };
64529     } catch (std::exception& e) {
64530       {
64531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64532       };
64533     } catch (Dali::DaliException e) {
64534       {
64535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64536       };
64537     } catch (...) {
64538       {
64539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64540       };
64541     }
64542   }
64543
64544   jresult = result;
64545   return jresult;
64546 }
64547
64548
64549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64550   unsigned int jresult ;
64551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64552   Dali::KeyEvent *arg2 = 0 ;
64553   SwigDirector_ViewImpl *darg = 0;
64554   bool result;
64555
64556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64557   arg2 = (Dali::KeyEvent *)jarg2;
64558   if (!arg2) {
64559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64560     return 0;
64561   }
64562   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64563   if (!darg) {
64564     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64565     return 0;
64566   }
64567   {
64568     try {
64569       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64570     } catch (std::out_of_range& e) {
64571       {
64572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64573       };
64574     } catch (std::exception& e) {
64575       {
64576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64577       };
64578     } catch (Dali::DaliException e) {
64579       {
64580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64581       };
64582     } catch (...) {
64583       {
64584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64585       };
64586     }
64587   }
64588
64589   jresult = result;
64590   return jresult;
64591 }
64592
64593
64594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64595   unsigned int jresult ;
64596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64597   Dali::KeyEvent *arg2 = 0 ;
64598   SwigDirector_ViewImpl *darg = 0;
64599   bool result;
64600
64601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64602   arg2 = (Dali::KeyEvent *)jarg2;
64603   if (!arg2) {
64604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64605     return 0;
64606   }
64607   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64608   if (!darg) {
64609     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64610     return 0;
64611   }
64612   {
64613     try {
64614       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64615     } catch (std::out_of_range& e) {
64616       {
64617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64618       };
64619     } catch (std::exception& e) {
64620       {
64621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64622       };
64623     } catch (Dali::DaliException e) {
64624       {
64625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64626       };
64627     } catch (...) {
64628       {
64629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64630       };
64631     }
64632   }
64633
64634   jresult = result;
64635   return jresult;
64636 }
64637
64638
64639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64640   unsigned int jresult ;
64641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64642   Dali::WheelEvent *arg2 = 0 ;
64643   SwigDirector_ViewImpl *darg = 0;
64644   bool result;
64645
64646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64647   arg2 = (Dali::WheelEvent *)jarg2;
64648   if (!arg2) {
64649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64650     return 0;
64651   }
64652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64653   if (!darg) {
64654     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64655     return 0;
64656   }
64657   {
64658     try {
64659       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64660     } catch (std::out_of_range& e) {
64661       {
64662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64663       };
64664     } catch (std::exception& e) {
64665       {
64666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64667       };
64668     } catch (Dali::DaliException e) {
64669       {
64670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64671       };
64672     } catch (...) {
64673       {
64674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64675       };
64676     }
64677   }
64678
64679   jresult = result;
64680   return jresult;
64681 }
64682
64683
64684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64685   unsigned int jresult ;
64686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64687   Dali::WheelEvent *arg2 = 0 ;
64688   SwigDirector_ViewImpl *darg = 0;
64689   bool result;
64690
64691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64692   arg2 = (Dali::WheelEvent *)jarg2;
64693   if (!arg2) {
64694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64695     return 0;
64696   }
64697   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64698   if (!darg) {
64699     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64700     return 0;
64701   }
64702   {
64703     try {
64704       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64705     } catch (std::out_of_range& e) {
64706       {
64707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64708       };
64709     } catch (std::exception& e) {
64710       {
64711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64712       };
64713     } catch (Dali::DaliException e) {
64714       {
64715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64716       };
64717     } catch (...) {
64718       {
64719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64720       };
64721     }
64722   }
64723
64724   jresult = result;
64725   return jresult;
64726 }
64727
64728
64729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64731   Dali::Vector2 *arg2 = 0 ;
64732   Dali::RelayoutContainer *arg3 = 0 ;
64733   SwigDirector_ViewImpl *darg = 0;
64734
64735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64736   arg2 = (Dali::Vector2 *)jarg2;
64737   if (!arg2) {
64738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64739     return ;
64740   }
64741   arg3 = (Dali::RelayoutContainer *)jarg3;
64742   if (!arg3) {
64743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64744     return ;
64745   }
64746   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64747   if (!darg) {
64748     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64749     return;
64750   }
64751   {
64752     try {
64753       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64754     } catch (std::out_of_range& e) {
64755       {
64756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64757       };
64758     } catch (std::exception& e) {
64759       {
64760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64761       };
64762     } catch (Dali::DaliException e) {
64763       {
64764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64765       };
64766     } catch (...) {
64767       {
64768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64769       };
64770     }
64771   }
64772
64773 }
64774
64775
64776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64778   Dali::Vector2 *arg2 = 0 ;
64779   Dali::RelayoutContainer *arg3 = 0 ;
64780   SwigDirector_ViewImpl *darg = 0;
64781
64782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64783   arg2 = (Dali::Vector2 *)jarg2;
64784   if (!arg2) {
64785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64786     return ;
64787   }
64788   arg3 = (Dali::RelayoutContainer *)jarg3;
64789   if (!arg3) {
64790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64791     return ;
64792   }
64793   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64794   if (!darg) {
64795     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64796     return;
64797   }
64798   {
64799     try {
64800       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64801     } catch (std::out_of_range& e) {
64802       {
64803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64804       };
64805     } catch (std::exception& e) {
64806       {
64807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64808       };
64809     } catch (Dali::DaliException e) {
64810       {
64811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64812       };
64813     } catch (...) {
64814       {
64815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64816       };
64817     }
64818   }
64819
64820 }
64821
64822
64823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64824   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64825   Dali::ResizePolicy::Type arg2 ;
64826   Dali::Dimension::Type arg3 ;
64827   SwigDirector_ViewImpl *darg = 0;
64828
64829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64830   arg2 = (Dali::ResizePolicy::Type)jarg2;
64831   arg3 = (Dali::Dimension::Type)jarg3;
64832   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64833   if (!darg) {
64834     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64835     return;
64836   }
64837   {
64838     try {
64839       (darg)->OnSetResizePolicy(arg2,arg3);
64840     } catch (std::out_of_range& e) {
64841       {
64842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64843       };
64844     } catch (std::exception& e) {
64845       {
64846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64847       };
64848     } catch (Dali::DaliException e) {
64849       {
64850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64851       };
64852     } catch (...) {
64853       {
64854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64855       };
64856     }
64857   }
64858
64859 }
64860
64861
64862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64864   Dali::ResizePolicy::Type arg2 ;
64865   Dali::Dimension::Type arg3 ;
64866   SwigDirector_ViewImpl *darg = 0;
64867
64868   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64869   arg2 = (Dali::ResizePolicy::Type)jarg2;
64870   arg3 = (Dali::Dimension::Type)jarg3;
64871   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64872   if (!darg) {
64873     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64874     return;
64875   }
64876   {
64877     try {
64878       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64879     } catch (std::out_of_range& e) {
64880       {
64881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64882       };
64883     } catch (std::exception& e) {
64884       {
64885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64886       };
64887     } catch (Dali::DaliException e) {
64888       {
64889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64890       };
64891     } catch (...) {
64892       {
64893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64894       };
64895     }
64896   }
64897
64898 }
64899
64900
64901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64902   void * jresult ;
64903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64904   SwigDirector_ViewImpl *darg = 0;
64905   Dali::Vector3 result;
64906
64907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64908   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64909   if (!darg) {
64910     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64911     return 0;
64912   }
64913   {
64914     try {
64915       result = (darg)->GetNaturalSize();
64916     } catch (std::out_of_range& e) {
64917       {
64918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64919       };
64920     } catch (std::exception& e) {
64921       {
64922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64923       };
64924     } catch (Dali::DaliException e) {
64925       {
64926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64927       };
64928     } catch (...) {
64929       {
64930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64931       };
64932     }
64933   }
64934
64935   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64936   return jresult;
64937 }
64938
64939
64940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64941   void * jresult ;
64942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64943   SwigDirector_ViewImpl *darg = 0;
64944   Dali::Vector3 result;
64945
64946   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64947   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64948   if (!darg) {
64949     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64950     return 0;
64951   }
64952   {
64953     try {
64954       result = (darg)->GetNaturalSizeSwigPublic();
64955     } catch (std::out_of_range& e) {
64956       {
64957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64958       };
64959     } catch (std::exception& e) {
64960       {
64961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64962       };
64963     } catch (Dali::DaliException e) {
64964       {
64965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64966       };
64967     } catch (...) {
64968       {
64969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64970       };
64971     }
64972   }
64973
64974   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64975   return jresult;
64976 }
64977
64978
64979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64980   float jresult ;
64981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64982   Dali::Actor *arg2 = 0 ;
64983   Dali::Dimension::Type arg3 ;
64984   SwigDirector_ViewImpl *darg = 0;
64985   float result;
64986
64987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64988   arg2 = (Dali::Actor *)jarg2;
64989   if (!arg2) {
64990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64991     return 0;
64992   }
64993   arg3 = (Dali::Dimension::Type)jarg3;
64994   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64995   if (!darg) {
64996     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64997     return 0;
64998   }
64999   {
65000     try {
65001       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65002     } catch (std::out_of_range& e) {
65003       {
65004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65005       };
65006     } catch (std::exception& e) {
65007       {
65008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65009       };
65010     } catch (Dali::DaliException e) {
65011       {
65012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65013       };
65014     } catch (...) {
65015       {
65016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65017       };
65018     }
65019   }
65020
65021   jresult = result;
65022   return jresult;
65023 }
65024
65025
65026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65027   float jresult ;
65028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65029   Dali::Actor *arg2 = 0 ;
65030   Dali::Dimension::Type arg3 ;
65031   SwigDirector_ViewImpl *darg = 0;
65032   float result;
65033
65034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65035   arg2 = (Dali::Actor *)jarg2;
65036   if (!arg2) {
65037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65038     return 0;
65039   }
65040   arg3 = (Dali::Dimension::Type)jarg3;
65041   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65042   if (!darg) {
65043     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65044     return 0;
65045   }
65046   {
65047     try {
65048       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65049     } catch (std::out_of_range& e) {
65050       {
65051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (std::exception& e) {
65054       {
65055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65056       };
65057     } catch (Dali::DaliException e) {
65058       {
65059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65060       };
65061     } catch (...) {
65062       {
65063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65064       };
65065     }
65066   }
65067
65068   jresult = result;
65069   return jresult;
65070 }
65071
65072
65073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65074   float jresult ;
65075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65076   float arg2 ;
65077   SwigDirector_ViewImpl *darg = 0;
65078   float result;
65079
65080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65081   arg2 = (float)jarg2;
65082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65083   if (!darg) {
65084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65085     return 0;
65086   }
65087   {
65088     try {
65089       result = (float)(darg)->GetHeightForWidth(arg2);
65090     } catch (std::out_of_range& e) {
65091       {
65092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65093       };
65094     } catch (std::exception& e) {
65095       {
65096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65097       };
65098     } catch (Dali::DaliException e) {
65099       {
65100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65101       };
65102     } catch (...) {
65103       {
65104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65105       };
65106     }
65107   }
65108
65109   jresult = result;
65110   return jresult;
65111 }
65112
65113
65114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65115   float jresult ;
65116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65117   float arg2 ;
65118   SwigDirector_ViewImpl *darg = 0;
65119   float result;
65120
65121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65122   arg2 = (float)jarg2;
65123   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65124   if (!darg) {
65125     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65126     return 0;
65127   }
65128   {
65129     try {
65130       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65131     } catch (std::out_of_range& e) {
65132       {
65133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65134       };
65135     } catch (std::exception& e) {
65136       {
65137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65138       };
65139     } catch (Dali::DaliException e) {
65140       {
65141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65142       };
65143     } catch (...) {
65144       {
65145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65146       };
65147     }
65148   }
65149
65150   jresult = result;
65151   return jresult;
65152 }
65153
65154
65155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65156   float jresult ;
65157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65158   float arg2 ;
65159   SwigDirector_ViewImpl *darg = 0;
65160   float result;
65161
65162   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65163   arg2 = (float)jarg2;
65164   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65165   if (!darg) {
65166     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65167     return 0;
65168   }
65169   {
65170     try {
65171       result = (float)(darg)->GetWidthForHeight(arg2);
65172     } catch (std::out_of_range& e) {
65173       {
65174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65175       };
65176     } catch (std::exception& e) {
65177       {
65178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65179       };
65180     } catch (Dali::DaliException e) {
65181       {
65182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65183       };
65184     } catch (...) {
65185       {
65186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65187       };
65188     }
65189   }
65190
65191   jresult = result;
65192   return jresult;
65193 }
65194
65195
65196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65197   float jresult ;
65198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65199   float arg2 ;
65200   SwigDirector_ViewImpl *darg = 0;
65201   float result;
65202
65203   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65204   arg2 = (float)jarg2;
65205   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65206   if (!darg) {
65207     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65208     return 0;
65209   }
65210   {
65211     try {
65212       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65213     } catch (std::out_of_range& e) {
65214       {
65215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65216       };
65217     } catch (std::exception& e) {
65218       {
65219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65220       };
65221     } catch (Dali::DaliException e) {
65222       {
65223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65224       };
65225     } catch (...) {
65226       {
65227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65228       };
65229     }
65230   }
65231
65232   jresult = result;
65233   return jresult;
65234 }
65235
65236
65237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65238   unsigned int jresult ;
65239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65240   Dali::Dimension::Type arg2 ;
65241   SwigDirector_ViewImpl *darg = 0;
65242   bool result;
65243
65244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65245   arg2 = (Dali::Dimension::Type)jarg2;
65246   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65247   if (!darg) {
65248     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65249     return 0;
65250   }
65251   {
65252     try {
65253       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65254     } catch (std::out_of_range& e) {
65255       {
65256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65257       };
65258     } catch (std::exception& e) {
65259       {
65260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65261       };
65262     } catch (Dali::DaliException e) {
65263       {
65264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65265       };
65266     } catch (...) {
65267       {
65268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65269       };
65270     }
65271   }
65272
65273   jresult = result;
65274   return jresult;
65275 }
65276
65277
65278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65279   unsigned int jresult ;
65280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65281   Dali::Dimension::Type arg2 ;
65282   SwigDirector_ViewImpl *darg = 0;
65283   bool result;
65284
65285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65286   arg2 = (Dali::Dimension::Type)jarg2;
65287   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65288   if (!darg) {
65289     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65290     return 0;
65291   }
65292   {
65293     try {
65294       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65295     } catch (std::out_of_range& e) {
65296       {
65297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65298       };
65299     } catch (std::exception& e) {
65300       {
65301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65302       };
65303     } catch (Dali::DaliException e) {
65304       {
65305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65306       };
65307     } catch (...) {
65308       {
65309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65310       };
65311     }
65312   }
65313
65314   jresult = result;
65315   return jresult;
65316 }
65317
65318
65319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65320   unsigned int jresult ;
65321   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65322   SwigDirector_ViewImpl *darg = 0;
65323   bool result;
65324
65325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65326   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65327   if (!darg) {
65328     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65329     return 0;
65330   }
65331   {
65332     try {
65333       result = (bool)(darg)->RelayoutDependentOnChildren();
65334     } catch (std::out_of_range& e) {
65335       {
65336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65337       };
65338     } catch (std::exception& e) {
65339       {
65340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65341       };
65342     } catch (Dali::DaliException e) {
65343       {
65344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65345       };
65346     } catch (...) {
65347       {
65348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65349       };
65350     }
65351   }
65352
65353   jresult = result;
65354   return jresult;
65355 }
65356
65357
65358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65359   unsigned int jresult ;
65360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65361   SwigDirector_ViewImpl *darg = 0;
65362   bool result;
65363
65364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65365   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65366   if (!darg) {
65367     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65368     return 0;
65369   }
65370   {
65371     try {
65372       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65373     } catch (std::out_of_range& e) {
65374       {
65375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65376       };
65377     } catch (std::exception& e) {
65378       {
65379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65380       };
65381     } catch (Dali::DaliException e) {
65382       {
65383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65384       };
65385     } catch (...) {
65386       {
65387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65388       };
65389     }
65390   }
65391
65392   jresult = result;
65393   return jresult;
65394 }
65395
65396
65397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65399   Dali::Dimension::Type arg2 ;
65400   SwigDirector_ViewImpl *darg = 0;
65401
65402   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65403   arg2 = (Dali::Dimension::Type)jarg2;
65404   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65405   if (!darg) {
65406     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65407     return;
65408   }
65409   {
65410     try {
65411       (darg)->OnCalculateRelayoutSize(arg2);
65412     } catch (std::out_of_range& e) {
65413       {
65414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65415       };
65416     } catch (std::exception& e) {
65417       {
65418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65419       };
65420     } catch (Dali::DaliException e) {
65421       {
65422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65423       };
65424     } catch (...) {
65425       {
65426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65427       };
65428     }
65429   }
65430
65431 }
65432
65433
65434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65436   Dali::Dimension::Type arg2 ;
65437   SwigDirector_ViewImpl *darg = 0;
65438
65439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65440   arg2 = (Dali::Dimension::Type)jarg2;
65441   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65442   if (!darg) {
65443     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65444     return;
65445   }
65446   {
65447     try {
65448       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65449     } catch (std::out_of_range& e) {
65450       {
65451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65452       };
65453     } catch (std::exception& e) {
65454       {
65455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65456       };
65457     } catch (Dali::DaliException e) {
65458       {
65459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65460       };
65461     } catch (...) {
65462       {
65463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65464       };
65465     }
65466   }
65467
65468 }
65469
65470
65471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65473   float arg2 ;
65474   Dali::Dimension::Type arg3 ;
65475   SwigDirector_ViewImpl *darg = 0;
65476
65477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65478   arg2 = (float)jarg2;
65479   arg3 = (Dali::Dimension::Type)jarg3;
65480   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65481   if (!darg) {
65482     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65483     return;
65484   }
65485   {
65486     try {
65487       (darg)->OnLayoutNegotiated(arg2,arg3);
65488     } catch (std::out_of_range& e) {
65489       {
65490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65491       };
65492     } catch (std::exception& e) {
65493       {
65494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65495       };
65496     } catch (Dali::DaliException e) {
65497       {
65498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65499       };
65500     } catch (...) {
65501       {
65502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65503       };
65504     }
65505   }
65506
65507 }
65508
65509
65510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65512   float arg2 ;
65513   Dali::Dimension::Type arg3 ;
65514   SwigDirector_ViewImpl *darg = 0;
65515
65516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65517   arg2 = (float)jarg2;
65518   arg3 = (Dali::Dimension::Type)jarg3;
65519   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65520   if (!darg) {
65521     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65522     return;
65523   }
65524   {
65525     try {
65526       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65527     } catch (std::out_of_range& e) {
65528       {
65529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65530       };
65531     } catch (std::exception& e) {
65532       {
65533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65534       };
65535     } catch (Dali::DaliException e) {
65536       {
65537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65538       };
65539     } catch (...) {
65540       {
65541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65542       };
65543     }
65544   }
65545
65546 }
65547
65548
65549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65551
65552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65553   {
65554     try {
65555       (arg1)->OnInitialize();
65556     } catch (std::out_of_range& e) {
65557       {
65558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65559       };
65560     } catch (std::exception& e) {
65561       {
65562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65563       };
65564     } catch (Dali::DaliException e) {
65565       {
65566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65567       };
65568     } catch (...) {
65569       {
65570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65571       };
65572     }
65573   }
65574
65575 }
65576
65577
65578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65580
65581   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65582   {
65583     try {
65584       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65585     } catch (std::out_of_range& e) {
65586       {
65587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65588       };
65589     } catch (std::exception& e) {
65590       {
65591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65592       };
65593     } catch (Dali::DaliException e) {
65594       {
65595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65596       };
65597     } catch (...) {
65598       {
65599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65600       };
65601     }
65602   }
65603
65604 }
65605
65606
65607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65609   Dali::Actor *arg2 = 0 ;
65610
65611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65612   arg2 = (Dali::Actor *)jarg2;
65613   if (!arg2) {
65614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65615     return ;
65616   }
65617   {
65618     try {
65619       (arg1)->OnControlChildAdd(*arg2);
65620     } catch (std::out_of_range& e) {
65621       {
65622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65623       };
65624     } catch (std::exception& e) {
65625       {
65626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65627       };
65628     } catch (Dali::DaliException e) {
65629       {
65630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65631       };
65632     } catch (...) {
65633       {
65634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65635       };
65636     }
65637   }
65638
65639 }
65640
65641
65642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65644   Dali::Actor *arg2 = 0 ;
65645
65646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65647   arg2 = (Dali::Actor *)jarg2;
65648   if (!arg2) {
65649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65650     return ;
65651   }
65652   {
65653     try {
65654       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65655     } catch (std::out_of_range& e) {
65656       {
65657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65658       };
65659     } catch (std::exception& e) {
65660       {
65661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65662       };
65663     } catch (Dali::DaliException e) {
65664       {
65665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65670       };
65671     }
65672   }
65673
65674 }
65675
65676
65677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65679   Dali::Actor *arg2 = 0 ;
65680
65681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65682   arg2 = (Dali::Actor *)jarg2;
65683   if (!arg2) {
65684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65685     return ;
65686   }
65687   {
65688     try {
65689       (arg1)->OnControlChildRemove(*arg2);
65690     } catch (std::out_of_range& e) {
65691       {
65692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65693       };
65694     } catch (std::exception& e) {
65695       {
65696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65697       };
65698     } catch (Dali::DaliException e) {
65699       {
65700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65701       };
65702     } catch (...) {
65703       {
65704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65705       };
65706     }
65707   }
65708
65709 }
65710
65711
65712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65714   Dali::Actor *arg2 = 0 ;
65715
65716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65717   arg2 = (Dali::Actor *)jarg2;
65718   if (!arg2) {
65719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65720     return ;
65721   }
65722   {
65723     try {
65724       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65725     } catch (std::out_of_range& e) {
65726       {
65727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65728       };
65729     } catch (std::exception& e) {
65730       {
65731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65732       };
65733     } catch (Dali::DaliException e) {
65734       {
65735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65736       };
65737     } catch (...) {
65738       {
65739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65740       };
65741     }
65742   }
65743
65744 }
65745
65746
65747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65749   Dali::Toolkit::StyleManager arg2 ;
65750   Dali::StyleChange::Type arg3 ;
65751   Dali::Toolkit::StyleManager *argp2 ;
65752
65753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65754   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65755   if (!argp2) {
65756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65757     return ;
65758   }
65759   arg2 = *argp2;
65760   arg3 = (Dali::StyleChange::Type)jarg3;
65761   {
65762     try {
65763       (arg1)->OnStyleChange(arg2,arg3);
65764     } catch (std::out_of_range& e) {
65765       {
65766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65767       };
65768     } catch (std::exception& e) {
65769       {
65770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65771       };
65772     } catch (Dali::DaliException e) {
65773       {
65774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65775       };
65776     } catch (...) {
65777       {
65778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65779       };
65780     }
65781   }
65782
65783 }
65784
65785
65786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65788   Dali::Toolkit::StyleManager arg2 ;
65789   Dali::StyleChange::Type arg3 ;
65790   Dali::Toolkit::StyleManager *argp2 ;
65791
65792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65793   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65794   if (!argp2) {
65795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65796     return ;
65797   }
65798   arg2 = *argp2;
65799   arg3 = (Dali::StyleChange::Type)jarg3;
65800   {
65801     try {
65802       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65803     } catch (std::out_of_range& e) {
65804       {
65805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65806       };
65807     } catch (std::exception& e) {
65808       {
65809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65810       };
65811     } catch (Dali::DaliException e) {
65812       {
65813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65814       };
65815     } catch (...) {
65816       {
65817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65818       };
65819     }
65820   }
65821
65822 }
65823
65824
65825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65826   unsigned int jresult ;
65827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65828   bool result;
65829
65830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65831   {
65832     try {
65833       result = (bool)(arg1)->OnAccessibilityActivated();
65834     } catch (std::out_of_range& e) {
65835       {
65836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65837       };
65838     } catch (std::exception& e) {
65839       {
65840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65841       };
65842     } catch (Dali::DaliException e) {
65843       {
65844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65845       };
65846     } catch (...) {
65847       {
65848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65849       };
65850     }
65851   }
65852
65853   jresult = result;
65854   return jresult;
65855 }
65856
65857
65858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65859   unsigned int jresult ;
65860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65861   bool result;
65862
65863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65864   {
65865     try {
65866       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65867     } catch (std::out_of_range& e) {
65868       {
65869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65870       };
65871     } catch (std::exception& e) {
65872       {
65873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65874       };
65875     } catch (Dali::DaliException e) {
65876       {
65877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65878       };
65879     } catch (...) {
65880       {
65881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65882       };
65883     }
65884   }
65885
65886   jresult = result;
65887   return jresult;
65888 }
65889
65890
65891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65892   unsigned int jresult ;
65893   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65894   Dali::PanGesture arg2 ;
65895   Dali::PanGesture *argp2 ;
65896   bool result;
65897
65898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65899   argp2 = (Dali::PanGesture *)jarg2;
65900   if (!argp2) {
65901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65902     return 0;
65903   }
65904   arg2 = *argp2;
65905   {
65906     try {
65907       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65908     } catch (std::out_of_range& e) {
65909       {
65910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65911       };
65912     } catch (std::exception& e) {
65913       {
65914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65915       };
65916     } catch (Dali::DaliException e) {
65917       {
65918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65919       };
65920     } catch (...) {
65921       {
65922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65923       };
65924     }
65925   }
65926
65927   jresult = result;
65928   return jresult;
65929 }
65930
65931
65932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65933   unsigned int jresult ;
65934   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65935   Dali::PanGesture arg2 ;
65936   Dali::PanGesture *argp2 ;
65937   bool result;
65938
65939   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65940   argp2 = (Dali::PanGesture *)jarg2;
65941   if (!argp2) {
65942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65943     return 0;
65944   }
65945   arg2 = *argp2;
65946   {
65947     try {
65948       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65949     } catch (std::out_of_range& e) {
65950       {
65951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65952       };
65953     } catch (std::exception& e) {
65954       {
65955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65956       };
65957     } catch (Dali::DaliException e) {
65958       {
65959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65960       };
65961     } catch (...) {
65962       {
65963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65964       };
65965     }
65966   }
65967
65968   jresult = result;
65969   return jresult;
65970 }
65971
65972
65973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65974   unsigned int jresult ;
65975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65976   Dali::TouchEvent *arg2 = 0 ;
65977   bool result;
65978
65979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65980   arg2 = (Dali::TouchEvent *)jarg2;
65981   if (!arg2) {
65982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65983     return 0;
65984   }
65985   {
65986     try {
65987       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65988     } catch (std::out_of_range& e) {
65989       {
65990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65991       };
65992     } catch (std::exception& e) {
65993       {
65994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65995       };
65996     } catch (Dali::DaliException e) {
65997       {
65998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65999       };
66000     } catch (...) {
66001       {
66002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66003       };
66004     }
66005   }
66006
66007   jresult = result;
66008   return jresult;
66009 }
66010
66011
66012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66013   unsigned int jresult ;
66014   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66015   Dali::TouchEvent *arg2 = 0 ;
66016   bool result;
66017
66018   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66019   arg2 = (Dali::TouchEvent *)jarg2;
66020   if (!arg2) {
66021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66022     return 0;
66023   }
66024   {
66025     try {
66026       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66027     } catch (std::out_of_range& e) {
66028       {
66029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66030       };
66031     } catch (std::exception& e) {
66032       {
66033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66034       };
66035     } catch (Dali::DaliException e) {
66036       {
66037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66038       };
66039     } catch (...) {
66040       {
66041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66042       };
66043     }
66044   }
66045
66046   jresult = result;
66047   return jresult;
66048 }
66049
66050
66051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66052   unsigned int jresult ;
66053   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66054   bool arg2 ;
66055   bool result;
66056
66057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66058   arg2 = jarg2 ? true : false;
66059   {
66060     try {
66061       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66062     } catch (std::out_of_range& e) {
66063       {
66064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66065       };
66066     } catch (std::exception& e) {
66067       {
66068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66069       };
66070     } catch (Dali::DaliException e) {
66071       {
66072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66073       };
66074     } catch (...) {
66075       {
66076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66077       };
66078     }
66079   }
66080
66081   jresult = result;
66082   return jresult;
66083 }
66084
66085
66086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66087   unsigned int jresult ;
66088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66089   bool arg2 ;
66090   bool result;
66091
66092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66093   arg2 = jarg2 ? true : false;
66094   {
66095     try {
66096       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66097     } catch (std::out_of_range& e) {
66098       {
66099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66100       };
66101     } catch (std::exception& e) {
66102       {
66103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66104       };
66105     } catch (Dali::DaliException e) {
66106       {
66107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66108       };
66109     } catch (...) {
66110       {
66111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66112       };
66113     }
66114   }
66115
66116   jresult = result;
66117   return jresult;
66118 }
66119
66120
66121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66122   unsigned int jresult ;
66123   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66124   bool result;
66125
66126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66127   {
66128     try {
66129       result = (bool)(arg1)->OnAccessibilityZoom();
66130     } catch (std::out_of_range& e) {
66131       {
66132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66133       };
66134     } catch (std::exception& e) {
66135       {
66136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66137       };
66138     } catch (Dali::DaliException e) {
66139       {
66140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66141       };
66142     } catch (...) {
66143       {
66144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66145       };
66146     }
66147   }
66148
66149   jresult = result;
66150   return jresult;
66151 }
66152
66153
66154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66155   unsigned int jresult ;
66156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66157   bool result;
66158
66159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66160   {
66161     try {
66162       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66163     } catch (std::out_of_range& e) {
66164       {
66165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66166       };
66167     } catch (std::exception& e) {
66168       {
66169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66170       };
66171     } catch (Dali::DaliException e) {
66172       {
66173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66174       };
66175     } catch (...) {
66176       {
66177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66178       };
66179     }
66180   }
66181
66182   jresult = result;
66183   return jresult;
66184 }
66185
66186
66187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66189
66190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66191   {
66192     try {
66193       (arg1)->OnKeyInputFocusGained();
66194     } catch (std::out_of_range& e) {
66195       {
66196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66197       };
66198     } catch (std::exception& e) {
66199       {
66200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66201       };
66202     } catch (Dali::DaliException e) {
66203       {
66204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66205       };
66206     } catch (...) {
66207       {
66208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66209       };
66210     }
66211   }
66212
66213 }
66214
66215
66216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66218
66219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66220   {
66221     try {
66222       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66223     } catch (std::out_of_range& e) {
66224       {
66225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66226       };
66227     } catch (std::exception& e) {
66228       {
66229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66230       };
66231     } catch (Dali::DaliException e) {
66232       {
66233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66234       };
66235     } catch (...) {
66236       {
66237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66238       };
66239     }
66240   }
66241
66242 }
66243
66244
66245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66247
66248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66249   {
66250     try {
66251       (arg1)->OnKeyInputFocusLost();
66252     } catch (std::out_of_range& e) {
66253       {
66254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66255       };
66256     } catch (std::exception& e) {
66257       {
66258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66259       };
66260     } catch (Dali::DaliException e) {
66261       {
66262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66263       };
66264     } catch (...) {
66265       {
66266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66267       };
66268     }
66269   }
66270
66271 }
66272
66273
66274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66276
66277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66278   {
66279     try {
66280       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66281     } catch (std::out_of_range& e) {
66282       {
66283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66284       };
66285     } catch (std::exception& e) {
66286       {
66287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66288       };
66289     } catch (Dali::DaliException e) {
66290       {
66291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66292       };
66293     } catch (...) {
66294       {
66295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66296       };
66297     }
66298   }
66299
66300 }
66301
66302
66303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66304   void * jresult ;
66305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66306   Dali::Actor arg2 ;
66307   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66308   bool arg4 ;
66309   Dali::Actor *argp2 ;
66310   Dali::Actor result;
66311
66312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66313   argp2 = (Dali::Actor *)jarg2;
66314   if (!argp2) {
66315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66316     return 0;
66317   }
66318   arg2 = *argp2;
66319   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66320   arg4 = jarg4 ? true : false;
66321   {
66322     try {
66323       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66324     } catch (std::out_of_range& e) {
66325       {
66326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66327       };
66328     } catch (std::exception& e) {
66329       {
66330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66331       };
66332     } catch (Dali::DaliException e) {
66333       {
66334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66335       };
66336     } catch (...) {
66337       {
66338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66339       };
66340     }
66341   }
66342
66343   jresult = new Dali::Actor((const Dali::Actor &)result);
66344   return jresult;
66345 }
66346
66347
66348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66349   void * jresult ;
66350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66351   Dali::Actor arg2 ;
66352   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66353   bool arg4 ;
66354   Dali::Actor *argp2 ;
66355   Dali::Actor result;
66356
66357   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66358   argp2 = (Dali::Actor *)jarg2;
66359   if (!argp2) {
66360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66361     return 0;
66362   }
66363   arg2 = *argp2;
66364   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66365   arg4 = jarg4 ? true : false;
66366   {
66367     try {
66368       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66369     } catch (std::out_of_range& e) {
66370       {
66371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66372       };
66373     } catch (std::exception& e) {
66374       {
66375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66376       };
66377     } catch (Dali::DaliException e) {
66378       {
66379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66380       };
66381     } catch (...) {
66382       {
66383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66384       };
66385     }
66386   }
66387
66388   jresult = new Dali::Actor((const Dali::Actor &)result);
66389   return jresult;
66390 }
66391
66392
66393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66395   Dali::Actor arg2 ;
66396   Dali::Actor *argp2 ;
66397
66398   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66399   argp2 = (Dali::Actor *)jarg2;
66400   if (!argp2) {
66401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66402     return ;
66403   }
66404   arg2 = *argp2;
66405   {
66406     try {
66407       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66408     } catch (std::out_of_range& e) {
66409       {
66410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66411       };
66412     } catch (std::exception& e) {
66413       {
66414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66415       };
66416     } catch (Dali::DaliException e) {
66417       {
66418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66419       };
66420     } catch (...) {
66421       {
66422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66423       };
66424     }
66425   }
66426
66427 }
66428
66429
66430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66432   Dali::Actor arg2 ;
66433   Dali::Actor *argp2 ;
66434
66435   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66436   argp2 = (Dali::Actor *)jarg2;
66437   if (!argp2) {
66438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66439     return ;
66440   }
66441   arg2 = *argp2;
66442   {
66443     try {
66444       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66445     } catch (std::out_of_range& e) {
66446       {
66447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66448       };
66449     } catch (std::exception& e) {
66450       {
66451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66452       };
66453     } catch (Dali::DaliException e) {
66454       {
66455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66456       };
66457     } catch (...) {
66458       {
66459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66460       };
66461     }
66462   }
66463
66464 }
66465
66466
66467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66468   unsigned int jresult ;
66469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66470   bool result;
66471
66472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66473   {
66474     try {
66475       result = (bool)(arg1)->OnKeyboardEnter();
66476     } catch (std::out_of_range& e) {
66477       {
66478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66479       };
66480     } catch (std::exception& e) {
66481       {
66482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66483       };
66484     } catch (Dali::DaliException e) {
66485       {
66486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66487       };
66488     } catch (...) {
66489       {
66490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66491       };
66492     }
66493   }
66494
66495   jresult = result;
66496   return jresult;
66497 }
66498
66499
66500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66501   unsigned int jresult ;
66502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66503   bool result;
66504
66505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66506   {
66507     try {
66508       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66509     } catch (std::out_of_range& e) {
66510       {
66511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66512       };
66513     } catch (std::exception& e) {
66514       {
66515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66516       };
66517     } catch (Dali::DaliException e) {
66518       {
66519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66520       };
66521     } catch (...) {
66522       {
66523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66524       };
66525     }
66526   }
66527
66528   jresult = result;
66529   return jresult;
66530 }
66531
66532
66533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66535   Dali::PinchGesture *arg2 = 0 ;
66536
66537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66538   arg2 = (Dali::PinchGesture *)jarg2;
66539   if (!arg2) {
66540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66541     return ;
66542   }
66543   {
66544     try {
66545       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66546     } catch (std::out_of_range& e) {
66547       {
66548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66549       };
66550     } catch (std::exception& e) {
66551       {
66552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66553       };
66554     } catch (Dali::DaliException e) {
66555       {
66556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66557       };
66558     } catch (...) {
66559       {
66560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66561       };
66562     }
66563   }
66564
66565 }
66566
66567
66568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66570   Dali::PinchGesture *arg2 = 0 ;
66571
66572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66573   arg2 = (Dali::PinchGesture *)jarg2;
66574   if (!arg2) {
66575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66576     return ;
66577   }
66578   {
66579     try {
66580       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66581     } catch (std::out_of_range& e) {
66582       {
66583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66584       };
66585     } catch (std::exception& e) {
66586       {
66587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66588       };
66589     } catch (Dali::DaliException e) {
66590       {
66591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66592       };
66593     } catch (...) {
66594       {
66595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66596       };
66597     }
66598   }
66599
66600 }
66601
66602
66603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66605   Dali::PanGesture *arg2 = 0 ;
66606
66607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66608   arg2 = (Dali::PanGesture *)jarg2;
66609   if (!arg2) {
66610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66611     return ;
66612   }
66613   {
66614     try {
66615       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66616     } catch (std::out_of_range& e) {
66617       {
66618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66619       };
66620     } catch (std::exception& e) {
66621       {
66622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66623       };
66624     } catch (Dali::DaliException e) {
66625       {
66626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66627       };
66628     } catch (...) {
66629       {
66630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66631       };
66632     }
66633   }
66634
66635 }
66636
66637
66638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66640   Dali::PanGesture *arg2 = 0 ;
66641
66642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66643   arg2 = (Dali::PanGesture *)jarg2;
66644   if (!arg2) {
66645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66646     return ;
66647   }
66648   {
66649     try {
66650       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66651     } catch (std::out_of_range& e) {
66652       {
66653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66654       };
66655     } catch (std::exception& e) {
66656       {
66657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66658       };
66659     } catch (Dali::DaliException e) {
66660       {
66661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66662       };
66663     } catch (...) {
66664       {
66665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66666       };
66667     }
66668   }
66669
66670 }
66671
66672
66673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66675   Dali::TapGesture *arg2 = 0 ;
66676
66677   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66678   arg2 = (Dali::TapGesture *)jarg2;
66679   if (!arg2) {
66680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66681     return ;
66682   }
66683   {
66684     try {
66685       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66686     } catch (std::out_of_range& e) {
66687       {
66688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66689       };
66690     } catch (std::exception& e) {
66691       {
66692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66693       };
66694     } catch (Dali::DaliException e) {
66695       {
66696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66697       };
66698     } catch (...) {
66699       {
66700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66701       };
66702     }
66703   }
66704
66705 }
66706
66707
66708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66710   Dali::TapGesture *arg2 = 0 ;
66711
66712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66713   arg2 = (Dali::TapGesture *)jarg2;
66714   if (!arg2) {
66715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66716     return ;
66717   }
66718   {
66719     try {
66720       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66721     } catch (std::out_of_range& e) {
66722       {
66723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66724       };
66725     } catch (std::exception& e) {
66726       {
66727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66728       };
66729     } catch (Dali::DaliException e) {
66730       {
66731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66732       };
66733     } catch (...) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66736       };
66737     }
66738   }
66739
66740 }
66741
66742
66743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66745   Dali::LongPressGesture *arg2 = 0 ;
66746
66747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66748   arg2 = (Dali::LongPressGesture *)jarg2;
66749   if (!arg2) {
66750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66751     return ;
66752   }
66753   {
66754     try {
66755       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66756     } catch (std::out_of_range& e) {
66757       {
66758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66759       };
66760     } catch (std::exception& e) {
66761       {
66762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66763       };
66764     } catch (Dali::DaliException e) {
66765       {
66766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66767       };
66768     } catch (...) {
66769       {
66770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66771       };
66772     }
66773   }
66774
66775 }
66776
66777
66778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66779   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66780   Dali::LongPressGesture *arg2 = 0 ;
66781
66782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66783   arg2 = (Dali::LongPressGesture *)jarg2;
66784   if (!arg2) {
66785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66786     return ;
66787   }
66788   {
66789     try {
66790       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66791     } catch (std::out_of_range& e) {
66792       {
66793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66794       };
66795     } catch (std::exception& e) {
66796       {
66797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66798       };
66799     } catch (Dali::DaliException e) {
66800       {
66801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66802       };
66803     } catch (...) {
66804       {
66805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66806       };
66807     }
66808   }
66809
66810 }
66811
66812
66813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66814   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66815   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66816   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66817
66818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66819   arg2 = (Dali::SlotObserver *)jarg2;
66820   arg3 = (Dali::CallbackBase *)jarg3;
66821   {
66822     try {
66823       (arg1)->SignalConnected(arg2,arg3);
66824     } catch (std::out_of_range& e) {
66825       {
66826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66827       };
66828     } catch (std::exception& e) {
66829       {
66830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66831       };
66832     } catch (Dali::DaliException e) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66835       };
66836     } catch (...) {
66837       {
66838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66839       };
66840     }
66841   }
66842
66843 }
66844
66845
66846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66847   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66848   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66849   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66850
66851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66852   arg2 = (Dali::SlotObserver *)jarg2;
66853   arg3 = (Dali::CallbackBase *)jarg3;
66854   {
66855     try {
66856       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66857     } catch (std::out_of_range& e) {
66858       {
66859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66860       };
66861     } catch (std::exception& e) {
66862       {
66863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66864       };
66865     } catch (Dali::DaliException e) {
66866       {
66867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66868       };
66869     } catch (...) {
66870       {
66871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66872       };
66873     }
66874   }
66875
66876 }
66877
66878
66879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66881   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66882   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66883
66884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66885   arg2 = (Dali::SlotObserver *)jarg2;
66886   arg3 = (Dali::CallbackBase *)jarg3;
66887   {
66888     try {
66889       (arg1)->SignalDisconnected(arg2,arg3);
66890     } catch (std::out_of_range& e) {
66891       {
66892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66893       };
66894     } catch (std::exception& e) {
66895       {
66896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66897       };
66898     } catch (Dali::DaliException e) {
66899       {
66900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66901       };
66902     } catch (...) {
66903       {
66904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66905       };
66906     }
66907   }
66908
66909 }
66910
66911
66912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66914   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66915   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66916
66917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66918   arg2 = (Dali::SlotObserver *)jarg2;
66919   arg3 = (Dali::CallbackBase *)jarg3;
66920   {
66921     try {
66922       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66923     } catch (std::out_of_range& e) {
66924       {
66925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66926       };
66927     } catch (std::exception& e) {
66928       {
66929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66930       };
66931     } catch (Dali::DaliException e) {
66932       {
66933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66934       };
66935     } catch (...) {
66936       {
66937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66938       };
66939     }
66940   }
66941
66942 }
66943
66944
66945 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) {
66946   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66947   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66948   if (director) {
66949     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);
66950   }
66951 }
66952
66953
66954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66955   void * jresult ;
66956   Dali::Toolkit::Control *arg1 = 0 ;
66957   Dali::Toolkit::Internal::Control *result = 0 ;
66958
66959   arg1 = (Dali::Toolkit::Control *)jarg1;
66960   if (!arg1) {
66961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66962     return 0;
66963   }
66964   {
66965     try {
66966       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66967     } catch (std::out_of_range& e) {
66968       {
66969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66970       };
66971     } catch (std::exception& e) {
66972       {
66973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66974       };
66975     } catch (Dali::DaliException e) {
66976       {
66977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66978       };
66979     } catch (...) {
66980       {
66981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66982       };
66983     }
66984   }
66985
66986   jresult = (void *)result;
66987   return jresult;
66988 }
66989
66990
66991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66992   int jresult ;
66993   int result;
66994
66995   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66996   jresult = (int)result;
66997   return jresult;
66998 }
66999
67000
67001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67002   int jresult ;
67003   int result;
67004
67005   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67006   jresult = (int)result;
67007   return jresult;
67008 }
67009
67010
67011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67012   int jresult ;
67013   int result;
67014
67015   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67016   jresult = (int)result;
67017   return jresult;
67018 }
67019
67020
67021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67022   int jresult ;
67023   int result;
67024
67025   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67026   jresult = (int)result;
67027   return jresult;
67028 }
67029
67030
67031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67032   int jresult ;
67033   int result;
67034
67035   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67036   jresult = (int)result;
67037   return jresult;
67038 }
67039
67040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67041   int jresult ;
67042   int result;
67043
67044   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67045   jresult = (int)result;
67046   return jresult;
67047 }
67048
67049
67050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67051   int jresult ;
67052   int result;
67053
67054   result = (int)Dali::Toolkit::Control::Property::PADDING;
67055   jresult = (int)result;
67056   return jresult;
67057 }
67058
67059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67060   void * jresult ;
67061   Dali::Toolkit::Control::Property *result = 0 ;
67062
67063   {
67064     try {
67065       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67066     } catch (std::out_of_range& e) {
67067       {
67068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67069       };
67070     } catch (std::exception& e) {
67071       {
67072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67073       };
67074     } catch (Dali::DaliException e) {
67075       {
67076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67077       };
67078     } catch (...) {
67079       {
67080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67081       };
67082     }
67083   }
67084
67085   jresult = (void *)result;
67086   return jresult;
67087 }
67088
67089
67090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67091   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67092
67093   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67094   {
67095     try {
67096       delete arg1;
67097     } catch (std::out_of_range& e) {
67098       {
67099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67100       };
67101     } catch (std::exception& e) {
67102       {
67103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67104       };
67105     } catch (Dali::DaliException e) {
67106       {
67107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67108       };
67109     } catch (...) {
67110       {
67111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67112       };
67113     }
67114   }
67115
67116 }
67117
67118
67119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67120   void * jresult ;
67121   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67122
67123   {
67124     try {
67125       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67126     } catch (std::out_of_range& e) {
67127       {
67128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67129       };
67130     } catch (std::exception& e) {
67131       {
67132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67133       };
67134     } catch (Dali::DaliException e) {
67135       {
67136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67137       };
67138     } catch (...) {
67139       {
67140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67141       };
67142     }
67143   }
67144
67145   jresult = (void *)result;
67146   return jresult;
67147 }
67148
67149
67150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67151   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67152
67153   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67154   {
67155     try {
67156       delete arg1;
67157     } catch (std::out_of_range& e) {
67158       {
67159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67160       };
67161     } catch (std::exception& e) {
67162       {
67163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67164       };
67165     } catch (Dali::DaliException e) {
67166       {
67167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67168       };
67169     } catch (...) {
67170       {
67171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67172       };
67173     }
67174   }
67175
67176 }
67177
67178
67179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67180   void * jresult ;
67181   Dali::Toolkit::Control result;
67182
67183   {
67184     try {
67185       result = Dali::Toolkit::Control::New();
67186     } catch (std::out_of_range& e) {
67187       {
67188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67189       };
67190     } catch (std::exception& e) {
67191       {
67192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67193       };
67194     } catch (Dali::DaliException e) {
67195       {
67196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67197       };
67198     } catch (...) {
67199       {
67200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67201       };
67202     }
67203   }
67204
67205   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67206   return jresult;
67207 }
67208
67209
67210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67211   void * jresult ;
67212   Dali::Toolkit::Control *result = 0 ;
67213
67214   {
67215     try {
67216       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67217     } catch (std::out_of_range& e) {
67218       {
67219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67220       };
67221     } catch (std::exception& e) {
67222       {
67223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67224       };
67225     } catch (Dali::DaliException e) {
67226       {
67227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67228       };
67229     } catch (...) {
67230       {
67231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67232       };
67233     }
67234   }
67235
67236   jresult = (void *)result;
67237   return jresult;
67238 }
67239
67240
67241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67242   void * jresult ;
67243   Dali::Toolkit::Control *arg1 = 0 ;
67244   Dali::Toolkit::Control *result = 0 ;
67245
67246   arg1 = (Dali::Toolkit::Control *)jarg1;
67247   if (!arg1) {
67248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67249     return 0;
67250   }
67251   {
67252     try {
67253       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67254     } catch (std::out_of_range& e) {
67255       {
67256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67257       };
67258     } catch (std::exception& e) {
67259       {
67260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67261       };
67262     } catch (Dali::DaliException e) {
67263       {
67264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67265       };
67266     } catch (...) {
67267       {
67268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67269       };
67270     }
67271   }
67272
67273   jresult = (void *)result;
67274   return jresult;
67275 }
67276
67277
67278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67279   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67280
67281   arg1 = (Dali::Toolkit::Control *)jarg1;
67282   {
67283     try {
67284       delete arg1;
67285     } catch (std::out_of_range& e) {
67286       {
67287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67288       };
67289     } catch (std::exception& e) {
67290       {
67291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67292       };
67293     } catch (Dali::DaliException e) {
67294       {
67295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67296       };
67297     } catch (...) {
67298       {
67299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67300       };
67301     }
67302   }
67303
67304 }
67305
67306
67307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67308   void * jresult ;
67309   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67310   Dali::Toolkit::Control *arg2 = 0 ;
67311   Dali::Toolkit::Control *result = 0 ;
67312
67313   arg1 = (Dali::Toolkit::Control *)jarg1;
67314   arg2 = (Dali::Toolkit::Control *)jarg2;
67315   if (!arg2) {
67316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67317     return 0;
67318   }
67319   {
67320     try {
67321       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67322     } catch (std::out_of_range& e) {
67323       {
67324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67325       };
67326     } catch (std::exception& e) {
67327       {
67328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67329       };
67330     } catch (Dali::DaliException e) {
67331       {
67332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67333       };
67334     } catch (...) {
67335       {
67336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67337       };
67338     }
67339   }
67340
67341   jresult = (void *)result;
67342   return jresult;
67343 }
67344
67345
67346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67347   void * jresult ;
67348   Dali::BaseHandle arg1 ;
67349   Dali::BaseHandle *argp1 ;
67350   Dali::Toolkit::Control result;
67351
67352   argp1 = (Dali::BaseHandle *)jarg1;
67353   if (!argp1) {
67354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67355     return 0;
67356   }
67357   arg1 = *argp1;
67358   {
67359     try {
67360       result = Dali::Toolkit::Control::DownCast(arg1);
67361     } catch (std::out_of_range& e) {
67362       {
67363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67364       };
67365     } catch (std::exception& e) {
67366       {
67367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67368       };
67369     } catch (Dali::DaliException e) {
67370       {
67371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67372       };
67373     } catch (...) {
67374       {
67375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67376       };
67377     }
67378   }
67379
67380   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67381   return jresult;
67382 }
67383
67384
67385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67386   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67387
67388   arg1 = (Dali::Toolkit::Control *)jarg1;
67389   {
67390     try {
67391       (arg1)->SetKeyInputFocus();
67392     } catch (std::out_of_range& e) {
67393       {
67394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67395       };
67396     } catch (std::exception& e) {
67397       {
67398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67399       };
67400     } catch (Dali::DaliException e) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67403       };
67404     } catch (...) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67407       };
67408     }
67409   }
67410
67411 }
67412
67413
67414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67415   unsigned int jresult ;
67416   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67417   bool result;
67418
67419   arg1 = (Dali::Toolkit::Control *)jarg1;
67420   {
67421     try {
67422       result = (bool)(arg1)->HasKeyInputFocus();
67423     } catch (std::out_of_range& e) {
67424       {
67425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67426       };
67427     } catch (std::exception& e) {
67428       {
67429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67430       };
67431     } catch (Dali::DaliException e) {
67432       {
67433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67434       };
67435     } catch (...) {
67436       {
67437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67438       };
67439     }
67440   }
67441
67442   jresult = result;
67443   return jresult;
67444 }
67445
67446
67447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67448   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67449
67450   arg1 = (Dali::Toolkit::Control *)jarg1;
67451   {
67452     try {
67453       (arg1)->ClearKeyInputFocus();
67454     } catch (std::out_of_range& e) {
67455       {
67456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67457       };
67458     } catch (std::exception& e) {
67459       {
67460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67461       };
67462     } catch (Dali::DaliException e) {
67463       {
67464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67465       };
67466     } catch (...) {
67467       {
67468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67469       };
67470     }
67471   }
67472
67473 }
67474
67475
67476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67477   void * jresult ;
67478   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67479   Dali::PinchGestureDetector result;
67480
67481   arg1 = (Dali::Toolkit::Control *)jarg1;
67482   {
67483     try {
67484       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67485     } catch (std::out_of_range& e) {
67486       {
67487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67488       };
67489     } catch (std::exception& e) {
67490       {
67491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67492       };
67493     } catch (Dali::DaliException e) {
67494       {
67495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67496       };
67497     } catch (...) {
67498       {
67499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67500       };
67501     }
67502   }
67503
67504   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67505   return jresult;
67506 }
67507
67508
67509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67510   void * jresult ;
67511   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67512   Dali::PanGestureDetector result;
67513
67514   arg1 = (Dali::Toolkit::Control *)jarg1;
67515   {
67516     try {
67517       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67518     } catch (std::out_of_range& e) {
67519       {
67520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67521       };
67522     } catch (std::exception& e) {
67523       {
67524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67525       };
67526     } catch (Dali::DaliException e) {
67527       {
67528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67529       };
67530     } catch (...) {
67531       {
67532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67533       };
67534     }
67535   }
67536
67537   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67538   return jresult;
67539 }
67540
67541
67542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67543   void * jresult ;
67544   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67545   Dali::TapGestureDetector result;
67546
67547   arg1 = (Dali::Toolkit::Control *)jarg1;
67548   {
67549     try {
67550       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67551     } catch (std::out_of_range& e) {
67552       {
67553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67554       };
67555     } catch (std::exception& e) {
67556       {
67557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67558       };
67559     } catch (Dali::DaliException e) {
67560       {
67561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67562       };
67563     } catch (...) {
67564       {
67565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67566       };
67567     }
67568   }
67569
67570   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67571   return jresult;
67572 }
67573
67574
67575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67576   void * jresult ;
67577   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67578   Dali::LongPressGestureDetector result;
67579
67580   arg1 = (Dali::Toolkit::Control *)jarg1;
67581   {
67582     try {
67583       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67584     } catch (std::out_of_range& e) {
67585       {
67586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67587       };
67588     } catch (std::exception& e) {
67589       {
67590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67591       };
67592     } catch (Dali::DaliException e) {
67593       {
67594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67595       };
67596     } catch (...) {
67597       {
67598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67599       };
67600     }
67601   }
67602
67603   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67604   return jresult;
67605 }
67606
67607
67608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67609   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67610   std::string *arg2 = 0 ;
67611
67612   arg1 = (Dali::Toolkit::Control *)jarg1;
67613   if (!jarg2) {
67614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67615     return ;
67616   }
67617   std::string arg2_str(jarg2);
67618   arg2 = &arg2_str;
67619   {
67620     try {
67621       (arg1)->SetStyleName((std::string const &)*arg2);
67622     } catch (std::out_of_range& e) {
67623       {
67624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67625       };
67626     } catch (std::exception& e) {
67627       {
67628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67629       };
67630     } catch (Dali::DaliException e) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67633       };
67634     } catch (...) {
67635       {
67636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67637       };
67638     }
67639   }
67640
67641
67642   //argout typemap for const std::string&
67643
67644 }
67645
67646
67647 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67648   char * jresult ;
67649   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67650   std::string *result = 0 ;
67651
67652   arg1 = (Dali::Toolkit::Control *)jarg1;
67653   {
67654     try {
67655       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67656     } catch (std::out_of_range& e) {
67657       {
67658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67659       };
67660     } catch (std::exception& e) {
67661       {
67662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67663       };
67664     } catch (Dali::DaliException e) {
67665       {
67666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67667       };
67668     } catch (...) {
67669       {
67670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67671       };
67672     }
67673   }
67674
67675   jresult = SWIG_csharp_string_callback(result->c_str());
67676   return jresult;
67677 }
67678
67679
67680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67681   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67682   Dali::Vector4 *arg2 = 0 ;
67683
67684   arg1 = (Dali::Toolkit::Control *)jarg1;
67685   arg2 = (Dali::Vector4 *)jarg2;
67686   if (!arg2) {
67687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67688     return ;
67689   }
67690   {
67691     try {
67692       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67693     } catch (std::out_of_range& e) {
67694       {
67695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67696       };
67697     } catch (std::exception& e) {
67698       {
67699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67700       };
67701     } catch (Dali::DaliException e) {
67702       {
67703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67704       };
67705     } catch (...) {
67706       {
67707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67708       };
67709     }
67710   }
67711
67712 }
67713
67714
67715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67716   void * jresult ;
67717   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67718   Dali::Vector4 result;
67719
67720   arg1 = (Dali::Toolkit::Control *)jarg1;
67721   {
67722     try {
67723       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67724     } catch (std::out_of_range& e) {
67725       {
67726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67727       };
67728     } catch (std::exception& e) {
67729       {
67730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67731       };
67732     } catch (Dali::DaliException e) {
67733       {
67734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67735       };
67736     } catch (...) {
67737       {
67738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67739       };
67740     }
67741   }
67742
67743   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67744   return jresult;
67745 }
67746
67747
67748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67749   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67750   Dali::Image arg2 ;
67751   Dali::Image *argp2 ;
67752
67753   arg1 = (Dali::Toolkit::Control *)jarg1;
67754   argp2 = (Dali::Image *)jarg2;
67755   if (!argp2) {
67756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67757     return ;
67758   }
67759   arg2 = *argp2;
67760   {
67761     try {
67762       (arg1)->SetBackgroundImage(arg2);
67763     } catch (std::out_of_range& e) {
67764       {
67765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67766       };
67767     } catch (std::exception& e) {
67768       {
67769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67770       };
67771     } catch (Dali::DaliException e) {
67772       {
67773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67774       };
67775     } catch (...) {
67776       {
67777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67778       };
67779     }
67780   }
67781
67782 }
67783
67784
67785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67786   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67787
67788   arg1 = (Dali::Toolkit::Control *)jarg1;
67789   {
67790     try {
67791       (arg1)->ClearBackground();
67792     } catch (std::out_of_range& e) {
67793       {
67794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67795       };
67796     } catch (std::exception& e) {
67797       {
67798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67799       };
67800     } catch (Dali::DaliException e) {
67801       {
67802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67803       };
67804     } catch (...) {
67805       {
67806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67807       };
67808     }
67809   }
67810
67811 }
67812
67813
67814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67815   void * jresult ;
67816   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67817   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67818
67819   arg1 = (Dali::Toolkit::Control *)jarg1;
67820   {
67821     try {
67822       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67823     } catch (std::out_of_range& e) {
67824       {
67825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67826       };
67827     } catch (std::exception& e) {
67828       {
67829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67830       };
67831     } catch (Dali::DaliException e) {
67832       {
67833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67834       };
67835     } catch (...) {
67836       {
67837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67838       };
67839     }
67840   }
67841
67842   jresult = (void *)result;
67843   return jresult;
67844 }
67845
67846
67847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67848   void * jresult ;
67849   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67850   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67851
67852   arg1 = (Dali::Toolkit::Control *)jarg1;
67853   {
67854     try {
67855       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67856     } catch (std::out_of_range& e) {
67857       {
67858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67859       };
67860     } catch (std::exception& e) {
67861       {
67862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67863       };
67864     } catch (Dali::DaliException e) {
67865       {
67866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67867       };
67868     } catch (...) {
67869       {
67870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67871       };
67872     }
67873   }
67874
67875   jresult = (void *)result;
67876   return jresult;
67877 }
67878
67879
67880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67881   void * jresult ;
67882   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67883   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67884
67885   arg1 = (Dali::Toolkit::Control *)jarg1;
67886   {
67887     try {
67888       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67889     } catch (std::out_of_range& e) {
67890       {
67891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67892       };
67893     } catch (std::exception& e) {
67894       {
67895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67896       };
67897     } catch (Dali::DaliException e) {
67898       {
67899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67900       };
67901     } catch (...) {
67902       {
67903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67904       };
67905     }
67906   }
67907
67908   jresult = (void *)result;
67909   return jresult;
67910 }
67911
67912
67913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67914   void * jresult ;
67915   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67916   Dali::Toolkit::Control *result = 0 ;
67917
67918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67919   if (!arg1) {
67920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67921     return 0;
67922   }
67923   {
67924     try {
67925       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67926     } catch (std::out_of_range& e) {
67927       {
67928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67929       };
67930     } catch (std::exception& e) {
67931       {
67932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67933       };
67934     } catch (Dali::DaliException e) {
67935       {
67936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67937       };
67938     } catch (...) {
67939       {
67940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67941       };
67942     }
67943   }
67944
67945   jresult = (void *)result;
67946   return jresult;
67947 }
67948
67949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67950 {
67951   int jresult;
67952   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67953   arg1 = (Dali::Toolkit::Control *)jarg1;
67954
67955   if (!arg1) {
67956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67957     return 0;
67958   }
67959
67960   Dali::Property::Index arg2 = 0 ;
67961   arg2 = (Dali::Property::Index)jarg2;
67962
67963   Toolkit::Visual::ResourceStatus result;
67964   {
67965     try {
67966       result = arg1->GetVisualResourceStatus(arg2);
67967     } catch (std::out_of_range& e) {
67968       {
67969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67970       };
67971     } catch (std::exception& e) {
67972       {
67973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67974       };
67975     } catch (...) {
67976       {
67977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67978       };
67979     }
67980   }
67981   jresult = (int)(result);
67982   return jresult;
67983 }
67984
67985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67986 {
67987   void * jresult;
67988   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67989   arg1 = (Dali::Toolkit::Control *)jarg1;
67990
67991   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67992
67993   Dali::Toolkit::TransitionData *arg2 = 0 ;
67994   Dali::Animation result;
67995
67996   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67997   if (!arg2) {
67998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67999     return 0;
68000   }
68001   {
68002     try {
68003       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68004     } catch (std::out_of_range& e) {
68005       {
68006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68007       };
68008     } catch (std::exception& e) {
68009       {
68010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68011       };
68012     } catch (Dali::DaliException e) {
68013       {
68014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68015       };
68016     } catch (...) {
68017       {
68018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68019       };
68020     }
68021   }
68022
68023   jresult = new Dali::Animation((const Dali::Animation &)result);
68024   return jresult;
68025 }
68026
68027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68028 {
68029   Dali::Toolkit::Control arg1;
68030   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68031
68032   if (!argp1) {
68033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68034   }
68035   arg1 = *argp1;
68036
68037   Dali::Property::Index arg2 = 0 ;
68038   arg2 = (Dali::Property::Index)jarg2;
68039
68040   Dali::Property::Index arg3 = 0 ;
68041   arg3 = (Dali::Property::Index)jarg3;
68042
68043   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
68044
68045   {
68046     try {
68047       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
68048     } catch (std::out_of_range& e) {
68049       {
68050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68051       };
68052     } catch (std::exception& e) {
68053       {
68054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68055       };
68056     } catch (...) {
68057       {
68058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68059       };
68060     }
68061   }
68062
68063
68064 }
68065
68066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68067   void * jresult ;
68068   Dali::Toolkit::Control *arg1 = 0 ;
68069   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68070
68071   arg1 = (Dali::Toolkit::Control *)jarg1;
68072   if (!arg1) {
68073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68074     return 0;
68075   }
68076   {
68077     try {
68078       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68079     } catch (std::out_of_range& e) {
68080       {
68081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68082       };
68083     } catch (std::exception& e) {
68084       {
68085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68086       };
68087     } catch (Dali::DaliException e) {
68088       {
68089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68090       };
68091     } catch (...) {
68092       {
68093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68094       };
68095     }
68096   }
68097
68098   jresult = (void *)result;
68099   return jresult;
68100 }
68101
68102
68103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68104   unsigned int jresult ;
68105   Dali::Toolkit::Control *arg1 = 0 ;
68106   bool result;
68107
68108   arg1 = (Dali::Toolkit::Control *)jarg1;
68109   if (!arg1) {
68110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68111     return 0;
68112   }
68113   {
68114     try {
68115       result = (bool)arg1->IsResourceReady();
68116     } catch (std::out_of_range& e) {
68117       {
68118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68119       };
68120     } catch (std::exception& e) {
68121       {
68122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68123       };
68124     } catch (Dali::DaliException e) {
68125       {
68126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68127       };
68128     } catch (...) {
68129       {
68130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68131       };
68132     }
68133   }
68134
68135   jresult = result;
68136   return jresult;
68137 }
68138
68139
68140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68141   void * jresult ;
68142   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68143
68144   {
68145     try {
68146       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68147     } catch (std::out_of_range& e) {
68148       {
68149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68150       };
68151     } catch (std::exception& e) {
68152       {
68153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68154       };
68155     } catch (Dali::DaliException e) {
68156       {
68157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68158       };
68159     } catch (...) {
68160       {
68161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68162       };
68163     }
68164   }
68165
68166   jresult = (void *)result;
68167   return jresult;
68168 }
68169
68170
68171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68172   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68173
68174   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68175   {
68176     try {
68177       delete arg1;
68178     } catch (std::out_of_range& e) {
68179       {
68180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68181       };
68182     } catch (std::exception& e) {
68183       {
68184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68185       };
68186     } catch (Dali::DaliException e) {
68187       {
68188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68189       };
68190     } catch (...) {
68191       {
68192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68193       };
68194     }
68195   }
68196
68197 }
68198
68199
68200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68201   void * jresult ;
68202   Dali::Toolkit::KeyInputFocusManager result;
68203
68204   {
68205     try {
68206       result = Dali::Toolkit::KeyInputFocusManager::Get();
68207     } catch (std::out_of_range& e) {
68208       {
68209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68210       };
68211     } catch (std::exception& e) {
68212       {
68213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68214       };
68215     } catch (Dali::DaliException e) {
68216       {
68217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68218       };
68219     } catch (...) {
68220       {
68221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68222       };
68223     }
68224   }
68225
68226   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68227   return jresult;
68228 }
68229
68230
68231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68232   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68233   Dali::Toolkit::Control arg2 ;
68234   Dali::Toolkit::Control *argp2 ;
68235
68236   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68237   argp2 = (Dali::Toolkit::Control *)jarg2;
68238   if (!argp2) {
68239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68240     return ;
68241   }
68242   arg2 = *argp2;
68243   {
68244     try {
68245       (arg1)->SetFocus(arg2);
68246     } catch (std::out_of_range& e) {
68247       {
68248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68249       };
68250     } catch (std::exception& e) {
68251       {
68252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68253       };
68254     } catch (Dali::DaliException e) {
68255       {
68256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68257       };
68258     } catch (...) {
68259       {
68260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68261       };
68262     }
68263   }
68264
68265 }
68266
68267
68268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68269   void * jresult ;
68270   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68271   Dali::Toolkit::Control result;
68272
68273   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68274   {
68275     try {
68276       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68277     } catch (std::out_of_range& e) {
68278       {
68279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68280       };
68281     } catch (std::exception& e) {
68282       {
68283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68284       };
68285     } catch (Dali::DaliException e) {
68286       {
68287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68288       };
68289     } catch (...) {
68290       {
68291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68292       };
68293     }
68294   }
68295
68296   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68297   return jresult;
68298 }
68299
68300
68301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68302   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68303   Dali::Toolkit::Control arg2 ;
68304   Dali::Toolkit::Control *argp2 ;
68305
68306   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68307   argp2 = (Dali::Toolkit::Control *)jarg2;
68308   if (!argp2) {
68309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68310     return ;
68311   }
68312   arg2 = *argp2;
68313   {
68314     try {
68315       (arg1)->RemoveFocus(arg2);
68316     } catch (std::out_of_range& e) {
68317       {
68318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68319       };
68320     } catch (std::exception& e) {
68321       {
68322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68323       };
68324     } catch (Dali::DaliException e) {
68325       {
68326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68327       };
68328     } catch (...) {
68329       {
68330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68331       };
68332     }
68333   }
68334
68335 }
68336
68337
68338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68339   void * jresult ;
68340   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68341   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68342
68343   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68344   {
68345     try {
68346       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68347     } catch (std::out_of_range& e) {
68348       {
68349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68350       };
68351     } catch (std::exception& e) {
68352       {
68353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68354       };
68355     } catch (Dali::DaliException e) {
68356       {
68357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68358       };
68359     } catch (...) {
68360       {
68361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68362       };
68363     }
68364   }
68365
68366   jresult = (void *)result;
68367   return jresult;
68368 }
68369
68370
68371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68372   void * jresult ;
68373   Dali::Toolkit::Alignment::Padding *result = 0 ;
68374
68375   {
68376     try {
68377       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68378     } catch (std::out_of_range& e) {
68379       {
68380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68381       };
68382     } catch (std::exception& e) {
68383       {
68384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68385       };
68386     } catch (Dali::DaliException e) {
68387       {
68388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68389       };
68390     } catch (...) {
68391       {
68392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68393       };
68394     }
68395   }
68396
68397   jresult = (void *)result;
68398   return jresult;
68399 }
68400
68401
68402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68403   void * jresult ;
68404   float arg1 ;
68405   float arg2 ;
68406   float arg3 ;
68407   float arg4 ;
68408   Dali::Toolkit::Alignment::Padding *result = 0 ;
68409
68410   arg1 = (float)jarg1;
68411   arg2 = (float)jarg2;
68412   arg3 = (float)jarg3;
68413   arg4 = (float)jarg4;
68414   {
68415     try {
68416       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68417     } catch (std::out_of_range& e) {
68418       {
68419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68420       };
68421     } catch (std::exception& e) {
68422       {
68423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68424       };
68425     } catch (Dali::DaliException e) {
68426       {
68427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68428       };
68429     } catch (...) {
68430       {
68431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68432       };
68433     }
68434   }
68435
68436   jresult = (void *)result;
68437   return jresult;
68438 }
68439
68440
68441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68442   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68443   float arg2 ;
68444
68445   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68446   arg2 = (float)jarg2;
68447   if (arg1) (arg1)->left = arg2;
68448 }
68449
68450
68451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68452   float jresult ;
68453   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68454   float result;
68455
68456   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68457   result = (float) ((arg1)->left);
68458   jresult = result;
68459   return jresult;
68460 }
68461
68462
68463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68464   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68465   float arg2 ;
68466
68467   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68468   arg2 = (float)jarg2;
68469   if (arg1) (arg1)->right = arg2;
68470 }
68471
68472
68473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68474   float jresult ;
68475   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68476   float result;
68477
68478   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68479   result = (float) ((arg1)->right);
68480   jresult = result;
68481   return jresult;
68482 }
68483
68484
68485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68486   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68487   float arg2 ;
68488
68489   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68490   arg2 = (float)jarg2;
68491   if (arg1) (arg1)->top = arg2;
68492 }
68493
68494
68495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68496   float jresult ;
68497   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68498   float result;
68499
68500   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68501   result = (float) ((arg1)->top);
68502   jresult = result;
68503   return jresult;
68504 }
68505
68506
68507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68508   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68509   float arg2 ;
68510
68511   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68512   arg2 = (float)jarg2;
68513   if (arg1) (arg1)->bottom = arg2;
68514 }
68515
68516
68517 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68518   float jresult ;
68519   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68520   float result;
68521
68522   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68523   result = (float) ((arg1)->bottom);
68524   jresult = result;
68525   return jresult;
68526 }
68527
68528
68529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68530   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68531
68532   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68533   {
68534     try {
68535       delete arg1;
68536     } catch (std::out_of_range& e) {
68537       {
68538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68539       };
68540     } catch (std::exception& e) {
68541       {
68542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68543       };
68544     } catch (Dali::DaliException e) {
68545       {
68546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68547       };
68548     } catch (...) {
68549       {
68550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68551       };
68552     }
68553   }
68554
68555 }
68556
68557
68558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68559   void * jresult ;
68560   Dali::Toolkit::Alignment *result = 0 ;
68561
68562   {
68563     try {
68564       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68565     } catch (std::out_of_range& e) {
68566       {
68567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68568       };
68569     } catch (std::exception& e) {
68570       {
68571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68572       };
68573     } catch (Dali::DaliException e) {
68574       {
68575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68576       };
68577     } catch (...) {
68578       {
68579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68580       };
68581     }
68582   }
68583
68584   jresult = (void *)result;
68585   return jresult;
68586 }
68587
68588
68589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68590   void * jresult ;
68591   Dali::Toolkit::Alignment::Type arg1 ;
68592   Dali::Toolkit::Alignment::Type arg2 ;
68593   Dali::Toolkit::Alignment result;
68594
68595   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68596   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68597   {
68598     try {
68599       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68600     } catch (std::out_of_range& e) {
68601       {
68602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68603       };
68604     } catch (std::exception& e) {
68605       {
68606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68607       };
68608     } catch (Dali::DaliException e) {
68609       {
68610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68611       };
68612     } catch (...) {
68613       {
68614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68615       };
68616     }
68617   }
68618
68619   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68620   return jresult;
68621 }
68622
68623
68624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68625   void * jresult ;
68626   Dali::Toolkit::Alignment::Type arg1 ;
68627   Dali::Toolkit::Alignment result;
68628
68629   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68630   {
68631     try {
68632       result = Dali::Toolkit::Alignment::New(arg1);
68633     } catch (std::out_of_range& e) {
68634       {
68635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68636       };
68637     } catch (std::exception& e) {
68638       {
68639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68640       };
68641     } catch (Dali::DaliException e) {
68642       {
68643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68644       };
68645     } catch (...) {
68646       {
68647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68648       };
68649     }
68650   }
68651
68652   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68653   return jresult;
68654 }
68655
68656
68657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68658   void * jresult ;
68659   Dali::Toolkit::Alignment result;
68660
68661   {
68662     try {
68663       result = Dali::Toolkit::Alignment::New();
68664     } catch (std::out_of_range& e) {
68665       {
68666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68667       };
68668     } catch (std::exception& e) {
68669       {
68670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68671       };
68672     } catch (Dali::DaliException e) {
68673       {
68674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68675       };
68676     } catch (...) {
68677       {
68678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68679       };
68680     }
68681   }
68682
68683   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68684   return jresult;
68685 }
68686
68687
68688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68689   void * jresult ;
68690   Dali::Toolkit::Alignment *arg1 = 0 ;
68691   Dali::Toolkit::Alignment *result = 0 ;
68692
68693   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68694   if (!arg1) {
68695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68696     return 0;
68697   }
68698   {
68699     try {
68700       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68701     } catch (std::out_of_range& e) {
68702       {
68703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68704       };
68705     } catch (std::exception& e) {
68706       {
68707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68708       };
68709     } catch (Dali::DaliException e) {
68710       {
68711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68712       };
68713     } catch (...) {
68714       {
68715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68716       };
68717     }
68718   }
68719
68720   jresult = (void *)result;
68721   return jresult;
68722 }
68723
68724
68725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68726   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68727
68728   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68729   {
68730     try {
68731       delete arg1;
68732     } catch (std::out_of_range& e) {
68733       {
68734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68735       };
68736     } catch (std::exception& e) {
68737       {
68738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68739       };
68740     } catch (Dali::DaliException e) {
68741       {
68742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68743       };
68744     } catch (...) {
68745       {
68746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68747       };
68748     }
68749   }
68750
68751 }
68752
68753
68754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68755   void * jresult ;
68756   Dali::BaseHandle arg1 ;
68757   Dali::BaseHandle *argp1 ;
68758   Dali::Toolkit::Alignment result;
68759
68760   argp1 = (Dali::BaseHandle *)jarg1;
68761   if (!argp1) {
68762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68763     return 0;
68764   }
68765   arg1 = *argp1;
68766   {
68767     try {
68768       result = Dali::Toolkit::Alignment::DownCast(arg1);
68769     } catch (std::out_of_range& e) {
68770       {
68771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68772       };
68773     } catch (std::exception& e) {
68774       {
68775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68776       };
68777     } catch (Dali::DaliException e) {
68778       {
68779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68780       };
68781     } catch (...) {
68782       {
68783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68784       };
68785     }
68786   }
68787
68788   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68789   return jresult;
68790 }
68791
68792
68793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68794   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68795   Dali::Toolkit::Alignment::Type arg2 ;
68796
68797   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68798   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68799   {
68800     try {
68801       (arg1)->SetAlignmentType(arg2);
68802     } catch (std::out_of_range& e) {
68803       {
68804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68805       };
68806     } catch (std::exception& e) {
68807       {
68808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68809       };
68810     } catch (Dali::DaliException e) {
68811       {
68812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68813       };
68814     } catch (...) {
68815       {
68816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68817       };
68818     }
68819   }
68820
68821 }
68822
68823
68824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68825   int jresult ;
68826   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68827   Dali::Toolkit::Alignment::Type result;
68828
68829   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68830   {
68831     try {
68832       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68833     } catch (std::out_of_range& e) {
68834       {
68835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68836       };
68837     } catch (std::exception& e) {
68838       {
68839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68840       };
68841     } catch (Dali::DaliException e) {
68842       {
68843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68844       };
68845     } catch (...) {
68846       {
68847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68848       };
68849     }
68850   }
68851
68852   jresult = (int)result;
68853   return jresult;
68854 }
68855
68856
68857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68858   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68859   Dali::Toolkit::Alignment::Scaling arg2 ;
68860
68861   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68862   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68863   {
68864     try {
68865       (arg1)->SetScaling(arg2);
68866     } catch (std::out_of_range& e) {
68867       {
68868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68869       };
68870     } catch (std::exception& e) {
68871       {
68872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68873       };
68874     } catch (Dali::DaliException e) {
68875       {
68876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68877       };
68878     } catch (...) {
68879       {
68880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68881       };
68882     }
68883   }
68884
68885 }
68886
68887
68888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68889   int jresult ;
68890   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68891   Dali::Toolkit::Alignment::Scaling result;
68892
68893   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68894   {
68895     try {
68896       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68897     } catch (std::out_of_range& e) {
68898       {
68899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68900       };
68901     } catch (std::exception& e) {
68902       {
68903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68904       };
68905     } catch (Dali::DaliException e) {
68906       {
68907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68908       };
68909     } catch (...) {
68910       {
68911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68912       };
68913     }
68914   }
68915
68916   jresult = (int)result;
68917   return jresult;
68918 }
68919
68920
68921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68922   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68923   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68924
68925   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68926   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68927   if (!arg2) {
68928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68929     return ;
68930   }
68931   {
68932     try {
68933       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68934     } catch (std::out_of_range& e) {
68935       {
68936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68937       };
68938     } catch (std::exception& e) {
68939       {
68940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68941       };
68942     } catch (Dali::DaliException e) {
68943       {
68944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68945       };
68946     } catch (...) {
68947       {
68948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68949       };
68950     }
68951   }
68952
68953 }
68954
68955
68956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68957   void * jresult ;
68958   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68959   Dali::Toolkit::Alignment::Padding *result = 0 ;
68960
68961   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68962   {
68963     try {
68964       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68965     } catch (std::out_of_range& e) {
68966       {
68967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68968       };
68969     } catch (std::exception& e) {
68970       {
68971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68972       };
68973     } catch (Dali::DaliException e) {
68974       {
68975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68976       };
68977     } catch (...) {
68978       {
68979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68980       };
68981     }
68982   }
68983
68984   jresult = (void *)result;
68985   return jresult;
68986 }
68987
68988
68989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68990   void * jresult ;
68991   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68992   Dali::Toolkit::Alignment *arg2 = 0 ;
68993   Dali::Toolkit::Alignment *result = 0 ;
68994
68995   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68996   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68997   if (!arg2) {
68998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68999     return 0;
69000   }
69001   {
69002     try {
69003       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69004     } catch (std::out_of_range& e) {
69005       {
69006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69007       };
69008     } catch (std::exception& e) {
69009       {
69010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69011       };
69012     } catch (Dali::DaliException e) {
69013       {
69014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69015       };
69016     } catch (...) {
69017       {
69018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69019       };
69020     }
69021   }
69022
69023   jresult = (void *)result;
69024   return jresult;
69025 }
69026
69027
69028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69029   int jresult ;
69030   int result;
69031
69032   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69033   jresult = (int)result;
69034   return jresult;
69035 }
69036
69037
69038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69039   int jresult ;
69040   int result;
69041
69042   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69043   jresult = (int)result;
69044   return jresult;
69045 }
69046
69047
69048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69049   int jresult ;
69050   int result;
69051
69052   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69053   jresult = (int)result;
69054   return jresult;
69055 }
69056
69057
69058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69059   int jresult ;
69060   int result;
69061
69062   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69063   jresult = (int)result;
69064   return jresult;
69065 }
69066
69067
69068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69069   int jresult ;
69070   int result;
69071
69072   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69073   jresult = (int)result;
69074   return jresult;
69075 }
69076
69077
69078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69079   int jresult ;
69080   int result;
69081
69082   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69083   jresult = (int)result;
69084   return jresult;
69085 }
69086
69087
69088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69089   int jresult ;
69090   int result;
69091
69092   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69093   jresult = (int)result;
69094   return jresult;
69095 }
69096
69097
69098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69099   int jresult ;
69100   int result;
69101
69102   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69103   jresult = (int)result;
69104   return jresult;
69105 }
69106
69107
69108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69109   int jresult ;
69110   int result;
69111
69112   result = (int)Dali::Toolkit::Button::Property::LABEL;
69113   jresult = (int)result;
69114   return jresult;
69115 }
69116
69117
69118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69119   int jresult ;
69120   int result;
69121
69122   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69123   jresult = (int)result;
69124   return jresult;
69125 }
69126
69127
69128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69129   void * jresult ;
69130   Dali::Toolkit::Button::Property *result = 0 ;
69131
69132   {
69133     try {
69134       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69135     } catch (std::out_of_range& e) {
69136       {
69137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69138       };
69139     } catch (std::exception& e) {
69140       {
69141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69142       };
69143     } catch (Dali::DaliException e) {
69144       {
69145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69146       };
69147     } catch (...) {
69148       {
69149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69150       };
69151     }
69152   }
69153
69154   jresult = (void *)result;
69155   return jresult;
69156 }
69157
69158
69159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69160   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69161
69162   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69163   {
69164     try {
69165       delete arg1;
69166     } catch (std::out_of_range& e) {
69167       {
69168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69169       };
69170     } catch (std::exception& e) {
69171       {
69172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69173       };
69174     } catch (Dali::DaliException e) {
69175       {
69176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69177       };
69178     } catch (...) {
69179       {
69180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69181       };
69182     }
69183   }
69184
69185 }
69186
69187
69188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69189   void * jresult ;
69190   Dali::Toolkit::Button *result = 0 ;
69191
69192   {
69193     try {
69194       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69195     } catch (std::out_of_range& e) {
69196       {
69197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69198       };
69199     } catch (std::exception& e) {
69200       {
69201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69202       };
69203     } catch (Dali::DaliException e) {
69204       {
69205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69206       };
69207     } catch (...) {
69208       {
69209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69210       };
69211     }
69212   }
69213
69214   jresult = (void *)result;
69215   return jresult;
69216 }
69217
69218
69219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69220   void * jresult ;
69221   Dali::Toolkit::Button *arg1 = 0 ;
69222   Dali::Toolkit::Button *result = 0 ;
69223
69224   arg1 = (Dali::Toolkit::Button *)jarg1;
69225   if (!arg1) {
69226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69227     return 0;
69228   }
69229   {
69230     try {
69231       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69232     } catch (std::out_of_range& e) {
69233       {
69234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69235       };
69236     } catch (std::exception& e) {
69237       {
69238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69239       };
69240     } catch (Dali::DaliException e) {
69241       {
69242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69243       };
69244     } catch (...) {
69245       {
69246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69247       };
69248     }
69249   }
69250
69251   jresult = (void *)result;
69252   return jresult;
69253 }
69254
69255
69256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69257   void * jresult ;
69258   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69259   Dali::Toolkit::Button *arg2 = 0 ;
69260   Dali::Toolkit::Button *result = 0 ;
69261
69262   arg1 = (Dali::Toolkit::Button *)jarg1;
69263   arg2 = (Dali::Toolkit::Button *)jarg2;
69264   if (!arg2) {
69265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69266     return 0;
69267   }
69268   {
69269     try {
69270       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69271     } catch (std::out_of_range& e) {
69272       {
69273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69274       };
69275     } catch (std::exception& e) {
69276       {
69277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69278       };
69279     } catch (Dali::DaliException e) {
69280       {
69281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69282       };
69283     } catch (...) {
69284       {
69285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69286       };
69287     }
69288   }
69289
69290   jresult = (void *)result;
69291   return jresult;
69292 }
69293
69294
69295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69296   void * jresult ;
69297   Dali::BaseHandle arg1 ;
69298   Dali::BaseHandle *argp1 ;
69299   Dali::Toolkit::Button result;
69300
69301   argp1 = (Dali::BaseHandle *)jarg1;
69302   if (!argp1) {
69303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69304     return 0;
69305   }
69306   arg1 = *argp1;
69307   {
69308     try {
69309       result = Dali::Toolkit::Button::DownCast(arg1);
69310     } catch (std::out_of_range& e) {
69311       {
69312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69313       };
69314     } catch (std::exception& e) {
69315       {
69316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69317       };
69318     } catch (Dali::DaliException e) {
69319       {
69320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69321       };
69322     } catch (...) {
69323       {
69324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69325       };
69326     }
69327   }
69328
69329   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69330   return jresult;
69331 }
69332
69333
69334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69335   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69336
69337   arg1 = (Dali::Toolkit::Button *)jarg1;
69338   {
69339     try {
69340       delete arg1;
69341     } catch (std::out_of_range& e) {
69342       {
69343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69344       };
69345     } catch (std::exception& e) {
69346       {
69347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69348       };
69349     } catch (Dali::DaliException e) {
69350       {
69351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69352       };
69353     } catch (...) {
69354       {
69355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69356       };
69357     }
69358   }
69359
69360 }
69361
69362
69363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69364   unsigned int jresult ;
69365   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69366   bool result;
69367
69368   arg1 = (Dali::Toolkit::Button *)jarg1;
69369   {
69370     try {
69371       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69372     } catch (std::out_of_range& e) {
69373       {
69374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69375       };
69376     } catch (std::exception& e) {
69377       {
69378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69379       };
69380     } catch (Dali::DaliException e) {
69381       {
69382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69383       };
69384     } catch (...) {
69385       {
69386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69387       };
69388     }
69389   }
69390
69391   jresult = result;
69392   return jresult;
69393 }
69394
69395
69396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69397   unsigned int jresult ;
69398   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69399   bool result;
69400
69401   arg1 = (Dali::Toolkit::Button *)jarg1;
69402   {
69403     try {
69404       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69405     } catch (std::out_of_range& e) {
69406       {
69407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69408       };
69409     } catch (std::exception& e) {
69410       {
69411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69412       };
69413     } catch (Dali::DaliException e) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69416       };
69417     } catch (...) {
69418       {
69419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69420       };
69421     }
69422   }
69423
69424   jresult = result;
69425   return jresult;
69426 }
69427
69428
69429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69430   float jresult ;
69431   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69432   float result;
69433
69434   arg1 = (Dali::Toolkit::Button *)jarg1;
69435   {
69436     try {
69437       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69438     } catch (std::out_of_range& e) {
69439       {
69440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69441       };
69442     } catch (std::exception& e) {
69443       {
69444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69445       };
69446     } catch (Dali::DaliException e) {
69447       {
69448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69449       };
69450     } catch (...) {
69451       {
69452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69453       };
69454     }
69455   }
69456
69457   jresult = result;
69458   return jresult;
69459 }
69460
69461
69462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69463   float jresult ;
69464   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69465   float result;
69466
69467   arg1 = (Dali::Toolkit::Button *)jarg1;
69468   {
69469     try {
69470       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69471     } catch (std::out_of_range& e) {
69472       {
69473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69474       };
69475     } catch (std::exception& e) {
69476       {
69477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69478       };
69479     } catch (Dali::DaliException e) {
69480       {
69481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69482       };
69483     } catch (...) {
69484       {
69485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69486       };
69487     }
69488   }
69489
69490   jresult = result;
69491   return jresult;
69492 }
69493
69494
69495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69496   unsigned int jresult ;
69497   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69498   bool result;
69499
69500   arg1 = (Dali::Toolkit::Button *)jarg1;
69501   {
69502     try {
69503       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69504     } catch (std::out_of_range& e) {
69505       {
69506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69507       };
69508     } catch (std::exception& e) {
69509       {
69510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69511       };
69512     } catch (Dali::DaliException e) {
69513       {
69514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69515       };
69516     } catch (...) {
69517       {
69518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69519       };
69520     }
69521   }
69522
69523   jresult = result;
69524   return jresult;
69525 }
69526
69527
69528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69529   unsigned int jresult ;
69530   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69531   bool result;
69532
69533   arg1 = (Dali::Toolkit::Button *)jarg1;
69534   {
69535     try {
69536       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69537     } catch (std::out_of_range& e) {
69538       {
69539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69540       };
69541     } catch (std::exception& e) {
69542       {
69543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69544       };
69545     } catch (Dali::DaliException e) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69548       };
69549     } catch (...) {
69550       {
69551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69552       };
69553     }
69554   }
69555
69556   jresult = result;
69557   return jresult;
69558 }
69559
69560
69561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69562   float jresult ;
69563   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69564   float result;
69565
69566   arg1 = (Dali::Toolkit::Button *)jarg1;
69567   {
69568     try {
69569       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69570     } catch (std::out_of_range& e) {
69571       {
69572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69573       };
69574     } catch (std::exception& e) {
69575       {
69576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69577       };
69578     } catch (Dali::DaliException e) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69581       };
69582     } catch (...) {
69583       {
69584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69585       };
69586     }
69587   }
69588
69589   jresult = result;
69590   return jresult;
69591 }
69592
69593
69594 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69595   char * jresult ;
69596   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69597   std::string result;
69598
69599   arg1 = (Dali::Toolkit::Button *)jarg1;
69600   {
69601     try {
69602       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69603     } catch (std::out_of_range& e) {
69604       {
69605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69606       };
69607     } catch (std::exception& e) {
69608       {
69609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69610       };
69611     } catch (Dali::DaliException e) {
69612       {
69613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69614       };
69615     } catch (...) {
69616       {
69617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69618       };
69619     }
69620   }
69621
69622   jresult = SWIG_csharp_string_callback((&result)->c_str());
69623   return jresult;
69624 }
69625
69626
69627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69628   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69629   Dali::Actor arg2 ;
69630   Dali::Actor *argp2 ;
69631
69632   arg1 = (Dali::Toolkit::Button *)jarg1;
69633   argp2 = (Dali::Actor *)jarg2;
69634   if (!argp2) {
69635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69636     return ;
69637   }
69638   arg2 = *argp2;
69639   {
69640     try {
69641       (arg1)->SetLabel(arg2);
69642     } catch (std::out_of_range& e) {
69643       {
69644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69645       };
69646     } catch (std::exception& e) {
69647       {
69648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69649       };
69650     } catch (Dali::DaliException e) {
69651       {
69652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69653       };
69654     } catch (...) {
69655       {
69656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69657       };
69658     }
69659   }
69660
69661 }
69662
69663
69664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69665   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69666   Dali::Image arg2 ;
69667   Dali::Image *argp2 ;
69668
69669   arg1 = (Dali::Toolkit::Button *)jarg1;
69670   argp2 = (Dali::Image *)jarg2;
69671   if (!argp2) {
69672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69673     return ;
69674   }
69675   arg2 = *argp2;
69676   {
69677     try {
69678       (arg1)->SetButtonImage(arg2);
69679     } catch (std::out_of_range& e) {
69680       {
69681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69682       };
69683     } catch (std::exception& e) {
69684       {
69685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69686       };
69687     } catch (Dali::DaliException e) {
69688       {
69689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69690       };
69691     } catch (...) {
69692       {
69693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69694       };
69695     }
69696   }
69697
69698 }
69699
69700
69701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69702   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69703   Dali::Image arg2 ;
69704   Dali::Image *argp2 ;
69705
69706   arg1 = (Dali::Toolkit::Button *)jarg1;
69707   argp2 = (Dali::Image *)jarg2;
69708   if (!argp2) {
69709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69710     return ;
69711   }
69712   arg2 = *argp2;
69713   {
69714     try {
69715       (arg1)->SetSelectedImage(arg2);
69716     } catch (std::out_of_range& e) {
69717       {
69718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69719       };
69720     } catch (std::exception& e) {
69721       {
69722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69723       };
69724     } catch (Dali::DaliException e) {
69725       {
69726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69727       };
69728     } catch (...) {
69729       {
69730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69731       };
69732     }
69733   }
69734
69735 }
69736
69737
69738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69739   void * jresult ;
69740   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69741   Dali::Actor result;
69742
69743   arg1 = (Dali::Toolkit::Button *)jarg1;
69744   {
69745     try {
69746       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69747     } catch (std::out_of_range& e) {
69748       {
69749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69750       };
69751     } catch (std::exception& e) {
69752       {
69753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69754       };
69755     } catch (Dali::DaliException e) {
69756       {
69757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69758       };
69759     } catch (...) {
69760       {
69761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69762       };
69763     }
69764   }
69765
69766   jresult = new Dali::Actor((const Dali::Actor &)result);
69767   return jresult;
69768 }
69769
69770
69771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69772   void * jresult ;
69773   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69774   Dali::Actor result;
69775
69776   arg1 = (Dali::Toolkit::Button *)jarg1;
69777   {
69778     try {
69779       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69780     } catch (std::out_of_range& e) {
69781       {
69782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69783       };
69784     } catch (std::exception& e) {
69785       {
69786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69787       };
69788     } catch (Dali::DaliException e) {
69789       {
69790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69791       };
69792     } catch (...) {
69793       {
69794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69795       };
69796     }
69797   }
69798
69799   jresult = new Dali::Actor((const Dali::Actor &)result);
69800   return jresult;
69801 }
69802
69803
69804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69805   void * jresult ;
69806   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69807   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69808
69809   arg1 = (Dali::Toolkit::Button *)jarg1;
69810   {
69811     try {
69812       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69813     } catch (std::out_of_range& e) {
69814       {
69815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69816       };
69817     } catch (std::exception& e) {
69818       {
69819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69820       };
69821     } catch (Dali::DaliException e) {
69822       {
69823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69824       };
69825     } catch (...) {
69826       {
69827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69828       };
69829     }
69830   }
69831
69832   jresult = (void *)result;
69833   return jresult;
69834 }
69835
69836
69837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69838   void * jresult ;
69839   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69840   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69841
69842   arg1 = (Dali::Toolkit::Button *)jarg1;
69843   {
69844     try {
69845       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69846     } catch (std::out_of_range& e) {
69847       {
69848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69849       };
69850     } catch (std::exception& e) {
69851       {
69852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69853       };
69854     } catch (Dali::DaliException e) {
69855       {
69856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69857       };
69858     } catch (...) {
69859       {
69860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69861       };
69862     }
69863   }
69864
69865   jresult = (void *)result;
69866   return jresult;
69867 }
69868
69869
69870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69871   void * jresult ;
69872   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69873   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69874
69875   arg1 = (Dali::Toolkit::Button *)jarg1;
69876   {
69877     try {
69878       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69879     } catch (std::out_of_range& e) {
69880       {
69881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69882       };
69883     } catch (std::exception& e) {
69884       {
69885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69886       };
69887     } catch (Dali::DaliException e) {
69888       {
69889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69890       };
69891     } catch (...) {
69892       {
69893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69894       };
69895     }
69896   }
69897
69898   jresult = (void *)result;
69899   return jresult;
69900 }
69901
69902
69903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69904   void * jresult ;
69905   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69906   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69907
69908   arg1 = (Dali::Toolkit::Button *)jarg1;
69909   {
69910     try {
69911       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69912     } catch (std::out_of_range& e) {
69913       {
69914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69915       };
69916     } catch (std::exception& e) {
69917       {
69918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69919       };
69920     } catch (Dali::DaliException e) {
69921       {
69922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69923       };
69924     } catch (...) {
69925       {
69926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69927       };
69928     }
69929   }
69930
69931   jresult = (void *)result;
69932   return jresult;
69933 }
69934
69935
69936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69937   void * jresult ;
69938   Dali::Toolkit::CheckBoxButton *result = 0 ;
69939
69940   {
69941     try {
69942       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69943     } catch (std::out_of_range& e) {
69944       {
69945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69946       };
69947     } catch (std::exception& e) {
69948       {
69949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69950       };
69951     } catch (Dali::DaliException e) {
69952       {
69953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69954       };
69955     } catch (...) {
69956       {
69957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69958       };
69959     }
69960   }
69961
69962   jresult = (void *)result;
69963   return jresult;
69964 }
69965
69966
69967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69968   void * jresult ;
69969   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69970   Dali::Toolkit::CheckBoxButton *result = 0 ;
69971
69972   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69973   if (!arg1) {
69974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69975     return 0;
69976   }
69977   {
69978     try {
69979       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69980     } catch (std::out_of_range& e) {
69981       {
69982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69983       };
69984     } catch (std::exception& e) {
69985       {
69986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69987       };
69988     } catch (Dali::DaliException e) {
69989       {
69990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69991       };
69992     } catch (...) {
69993       {
69994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69995       };
69996     }
69997   }
69998
69999   jresult = (void *)result;
70000   return jresult;
70001 }
70002
70003
70004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70005   void * jresult ;
70006   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70007   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70008   Dali::Toolkit::CheckBoxButton *result = 0 ;
70009
70010   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70011   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70012   if (!arg2) {
70013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70014     return 0;
70015   }
70016   {
70017     try {
70018       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70019     } catch (std::out_of_range& e) {
70020       {
70021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70022       };
70023     } catch (std::exception& e) {
70024       {
70025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70026       };
70027     } catch (Dali::DaliException e) {
70028       {
70029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70030       };
70031     } catch (...) {
70032       {
70033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70034       };
70035     }
70036   }
70037
70038   jresult = (void *)result;
70039   return jresult;
70040 }
70041
70042
70043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70044   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70045
70046   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70047   {
70048     try {
70049       delete arg1;
70050     } catch (std::out_of_range& e) {
70051       {
70052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70053       };
70054     } catch (std::exception& e) {
70055       {
70056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70057       };
70058     } catch (Dali::DaliException e) {
70059       {
70060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70061       };
70062     } catch (...) {
70063       {
70064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70065       };
70066     }
70067   }
70068
70069 }
70070
70071
70072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70073   void * jresult ;
70074   Dali::Toolkit::CheckBoxButton result;
70075
70076   {
70077     try {
70078       result = Dali::Toolkit::CheckBoxButton::New();
70079     } catch (std::out_of_range& e) {
70080       {
70081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70082       };
70083     } catch (std::exception& e) {
70084       {
70085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70086       };
70087     } catch (Dali::DaliException e) {
70088       {
70089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70090       };
70091     } catch (...) {
70092       {
70093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70094       };
70095     }
70096   }
70097
70098   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70099   return jresult;
70100 }
70101
70102
70103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70104   void * jresult ;
70105   Dali::BaseHandle arg1 ;
70106   Dali::BaseHandle *argp1 ;
70107   Dali::Toolkit::CheckBoxButton result;
70108
70109   argp1 = (Dali::BaseHandle *)jarg1;
70110   if (!argp1) {
70111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70112     return 0;
70113   }
70114   arg1 = *argp1;
70115   {
70116     try {
70117       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70118     } catch (std::out_of_range& e) {
70119       {
70120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70121       };
70122     } catch (std::exception& e) {
70123       {
70124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70125       };
70126     } catch (Dali::DaliException e) {
70127       {
70128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70129       };
70130     } catch (...) {
70131       {
70132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70133       };
70134     }
70135   }
70136
70137   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70138   return jresult;
70139 }
70140
70141
70142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70143   int jresult ;
70144   int result;
70145
70146   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70147   jresult = (int)result;
70148   return jresult;
70149 }
70150
70151
70152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70153   int jresult ;
70154   int result;
70155
70156   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70157   jresult = (int)result;
70158   return jresult;
70159 }
70160
70161
70162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70163   int jresult ;
70164   int result;
70165
70166   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70167   jresult = (int)result;
70168   return jresult;
70169 }
70170
70171
70172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70173   int jresult ;
70174   int result;
70175
70176   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70177   jresult = (int)result;
70178   return jresult;
70179 }
70180
70181
70182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70183   int jresult ;
70184   int result;
70185
70186   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70187   jresult = (int)result;
70188   return jresult;
70189 }
70190
70191
70192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70193   void * jresult ;
70194   Dali::Toolkit::PushButton::Property *result = 0 ;
70195
70196   {
70197     try {
70198       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70199     } catch (std::out_of_range& e) {
70200       {
70201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70202       };
70203     } catch (std::exception& e) {
70204       {
70205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70206       };
70207     } catch (Dali::DaliException e) {
70208       {
70209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70210       };
70211     } catch (...) {
70212       {
70213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70214       };
70215     }
70216   }
70217
70218   jresult = (void *)result;
70219   return jresult;
70220 }
70221
70222
70223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70224   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70225
70226   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70227   {
70228     try {
70229       delete arg1;
70230     } catch (std::out_of_range& e) {
70231       {
70232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70233       };
70234     } catch (std::exception& e) {
70235       {
70236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70237       };
70238     } catch (Dali::DaliException e) {
70239       {
70240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70241       };
70242     } catch (...) {
70243       {
70244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70245       };
70246     }
70247   }
70248
70249 }
70250
70251
70252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70253   void * jresult ;
70254   Dali::Toolkit::PushButton *result = 0 ;
70255
70256   {
70257     try {
70258       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70259     } catch (std::out_of_range& e) {
70260       {
70261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70262       };
70263     } catch (std::exception& e) {
70264       {
70265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70266       };
70267     } catch (Dali::DaliException e) {
70268       {
70269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70270       };
70271     } catch (...) {
70272       {
70273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70274       };
70275     }
70276   }
70277
70278   jresult = (void *)result;
70279   return jresult;
70280 }
70281
70282
70283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70284   void * jresult ;
70285   Dali::Toolkit::PushButton *arg1 = 0 ;
70286   Dali::Toolkit::PushButton *result = 0 ;
70287
70288   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70289   if (!arg1) {
70290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70291     return 0;
70292   }
70293   {
70294     try {
70295       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70296     } catch (std::out_of_range& e) {
70297       {
70298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70299       };
70300     } catch (std::exception& e) {
70301       {
70302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70303       };
70304     } catch (Dali::DaliException e) {
70305       {
70306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70307       };
70308     } catch (...) {
70309       {
70310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70311       };
70312     }
70313   }
70314
70315   jresult = (void *)result;
70316   return jresult;
70317 }
70318
70319
70320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70321   void * jresult ;
70322   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70323   Dali::Toolkit::PushButton *arg2 = 0 ;
70324   Dali::Toolkit::PushButton *result = 0 ;
70325
70326   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70327   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70328   if (!arg2) {
70329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70330     return 0;
70331   }
70332   {
70333     try {
70334       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70335     } catch (std::out_of_range& e) {
70336       {
70337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70338       };
70339     } catch (std::exception& e) {
70340       {
70341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70342       };
70343     } catch (Dali::DaliException e) {
70344       {
70345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70346       };
70347     } catch (...) {
70348       {
70349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70350       };
70351     }
70352   }
70353
70354   jresult = (void *)result;
70355   return jresult;
70356 }
70357
70358
70359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70360   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70361
70362   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70363   {
70364     try {
70365       delete arg1;
70366     } catch (std::out_of_range& e) {
70367       {
70368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70369       };
70370     } catch (std::exception& e) {
70371       {
70372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70373       };
70374     } catch (Dali::DaliException e) {
70375       {
70376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70377       };
70378     } catch (...) {
70379       {
70380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70381       };
70382     }
70383   }
70384
70385 }
70386
70387
70388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70389   void * jresult ;
70390   Dali::Toolkit::PushButton result;
70391
70392   {
70393     try {
70394       result = Dali::Toolkit::PushButton::New();
70395     } catch (std::out_of_range& e) {
70396       {
70397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70398       };
70399     } catch (std::exception& e) {
70400       {
70401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70402       };
70403     } catch (Dali::DaliException e) {
70404       {
70405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70406       };
70407     } catch (...) {
70408       {
70409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70410       };
70411     }
70412   }
70413
70414   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70415   return jresult;
70416 }
70417
70418
70419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70420   void * jresult ;
70421   Dali::BaseHandle arg1 ;
70422   Dali::BaseHandle *argp1 ;
70423   Dali::Toolkit::PushButton result;
70424
70425   argp1 = (Dali::BaseHandle *)jarg1;
70426   if (!argp1) {
70427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70428     return 0;
70429   }
70430   arg1 = *argp1;
70431   {
70432     try {
70433       result = Dali::Toolkit::PushButton::DownCast(arg1);
70434     } catch (std::out_of_range& e) {
70435       {
70436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70437       };
70438     } catch (std::exception& e) {
70439       {
70440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70441       };
70442     } catch (Dali::DaliException e) {
70443       {
70444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70445       };
70446     } catch (...) {
70447       {
70448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70449       };
70450     }
70451   }
70452
70453   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70454   return jresult;
70455 }
70456
70457
70458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70459   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70460   Dali::Image arg2 ;
70461   Dali::Image *argp2 ;
70462
70463   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70464   argp2 = (Dali::Image *)jarg2;
70465   if (!argp2) {
70466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70467     return ;
70468   }
70469   arg2 = *argp2;
70470   {
70471     try {
70472       (arg1)->SetButtonImage(arg2);
70473     } catch (std::out_of_range& e) {
70474       {
70475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70476       };
70477     } catch (std::exception& e) {
70478       {
70479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70480       };
70481     } catch (Dali::DaliException e) {
70482       {
70483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70484       };
70485     } catch (...) {
70486       {
70487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70488       };
70489     }
70490   }
70491
70492 }
70493
70494
70495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70496   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70497   Dali::Actor arg2 ;
70498   Dali::Actor *argp2 ;
70499
70500   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70501   argp2 = (Dali::Actor *)jarg2;
70502   if (!argp2) {
70503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70504     return ;
70505   }
70506   arg2 = *argp2;
70507   {
70508     try {
70509       (arg1)->SetButtonImage(arg2);
70510     } catch (std::out_of_range& e) {
70511       {
70512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70513       };
70514     } catch (std::exception& e) {
70515       {
70516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70517       };
70518     } catch (Dali::DaliException e) {
70519       {
70520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70521       };
70522     } catch (...) {
70523       {
70524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70525       };
70526     }
70527   }
70528
70529 }
70530
70531
70532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70533   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70534   Dali::Actor arg2 ;
70535   Dali::Actor *argp2 ;
70536
70537   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70538   argp2 = (Dali::Actor *)jarg2;
70539   if (!argp2) {
70540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70541     return ;
70542   }
70543   arg2 = *argp2;
70544   {
70545     try {
70546       (arg1)->SetBackgroundImage(arg2);
70547     } catch (std::out_of_range& e) {
70548       {
70549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70550       };
70551     } catch (std::exception& e) {
70552       {
70553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70554       };
70555     } catch (Dali::DaliException e) {
70556       {
70557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70558       };
70559     } catch (...) {
70560       {
70561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70562       };
70563     }
70564   }
70565
70566 }
70567
70568
70569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70570   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70571   Dali::Image arg2 ;
70572   Dali::Image *argp2 ;
70573
70574   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70575   argp2 = (Dali::Image *)jarg2;
70576   if (!argp2) {
70577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70578     return ;
70579   }
70580   arg2 = *argp2;
70581   {
70582     try {
70583       (arg1)->SetSelectedImage(arg2);
70584     } catch (std::out_of_range& e) {
70585       {
70586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70587       };
70588     } catch (std::exception& e) {
70589       {
70590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70591       };
70592     } catch (Dali::DaliException e) {
70593       {
70594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70595       };
70596     } catch (...) {
70597       {
70598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70599       };
70600     }
70601   }
70602
70603 }
70604
70605
70606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70607   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70608   Dali::Actor arg2 ;
70609   Dali::Actor *argp2 ;
70610
70611   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70612   argp2 = (Dali::Actor *)jarg2;
70613   if (!argp2) {
70614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70615     return ;
70616   }
70617   arg2 = *argp2;
70618   {
70619     try {
70620       (arg1)->SetSelectedImage(arg2);
70621     } catch (std::out_of_range& e) {
70622       {
70623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70624       };
70625     } catch (std::exception& e) {
70626       {
70627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70628       };
70629     } catch (Dali::DaliException e) {
70630       {
70631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70632       };
70633     } catch (...) {
70634       {
70635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70636       };
70637     }
70638   }
70639
70640 }
70641
70642
70643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70644   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70645   Dali::Actor arg2 ;
70646   Dali::Actor *argp2 ;
70647
70648   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70649   argp2 = (Dali::Actor *)jarg2;
70650   if (!argp2) {
70651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70652     return ;
70653   }
70654   arg2 = *argp2;
70655   {
70656     try {
70657       (arg1)->SetSelectedBackgroundImage(arg2);
70658     } catch (std::out_of_range& e) {
70659       {
70660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70661       };
70662     } catch (std::exception& e) {
70663       {
70664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70665       };
70666     } catch (Dali::DaliException e) {
70667       {
70668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70669       };
70670     } catch (...) {
70671       {
70672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70673       };
70674     }
70675   }
70676
70677 }
70678
70679
70680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70681   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70682   Dali::Actor arg2 ;
70683   Dali::Actor *argp2 ;
70684
70685   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70686   argp2 = (Dali::Actor *)jarg2;
70687   if (!argp2) {
70688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70689     return ;
70690   }
70691   arg2 = *argp2;
70692   {
70693     try {
70694       (arg1)->SetDisabledBackgroundImage(arg2);
70695     } catch (std::out_of_range& e) {
70696       {
70697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70698       };
70699     } catch (std::exception& e) {
70700       {
70701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70702       };
70703     } catch (Dali::DaliException e) {
70704       {
70705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70706       };
70707     } catch (...) {
70708       {
70709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70710       };
70711     }
70712   }
70713
70714 }
70715
70716
70717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70718   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70719   Dali::Actor arg2 ;
70720   Dali::Actor *argp2 ;
70721
70722   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70723   argp2 = (Dali::Actor *)jarg2;
70724   if (!argp2) {
70725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70726     return ;
70727   }
70728   arg2 = *argp2;
70729   {
70730     try {
70731       (arg1)->SetDisabledImage(arg2);
70732     } catch (std::out_of_range& e) {
70733       {
70734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70735       };
70736     } catch (std::exception& e) {
70737       {
70738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70739       };
70740     } catch (Dali::DaliException e) {
70741       {
70742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70743       };
70744     } catch (...) {
70745       {
70746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70747       };
70748     }
70749   }
70750
70751 }
70752
70753
70754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70755   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70756   Dali::Actor arg2 ;
70757   Dali::Actor *argp2 ;
70758
70759   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70760   argp2 = (Dali::Actor *)jarg2;
70761   if (!argp2) {
70762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70763     return ;
70764   }
70765   arg2 = *argp2;
70766   {
70767     try {
70768       (arg1)->SetDisabledSelectedImage(arg2);
70769     } catch (std::out_of_range& e) {
70770       {
70771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70772       };
70773     } catch (std::exception& e) {
70774       {
70775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70776       };
70777     } catch (Dali::DaliException e) {
70778       {
70779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70780       };
70781     } catch (...) {
70782       {
70783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70784       };
70785     }
70786   }
70787
70788 }
70789
70790
70791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70792   void * jresult ;
70793   Dali::Toolkit::RadioButton *result = 0 ;
70794
70795   {
70796     try {
70797       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70798     } catch (std::out_of_range& e) {
70799       {
70800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70801       };
70802     } catch (std::exception& e) {
70803       {
70804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70805       };
70806     } catch (Dali::DaliException e) {
70807       {
70808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70809       };
70810     } catch (...) {
70811       {
70812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70813       };
70814     }
70815   }
70816
70817   jresult = (void *)result;
70818   return jresult;
70819 }
70820
70821
70822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70823   void * jresult ;
70824   Dali::Toolkit::RadioButton *arg1 = 0 ;
70825   Dali::Toolkit::RadioButton *result = 0 ;
70826
70827   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70828   if (!arg1) {
70829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70830     return 0;
70831   }
70832   {
70833     try {
70834       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
70835     } catch (std::out_of_range& e) {
70836       {
70837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70838       };
70839     } catch (std::exception& e) {
70840       {
70841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70842       };
70843     } catch (Dali::DaliException e) {
70844       {
70845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70846       };
70847     } catch (...) {
70848       {
70849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70850       };
70851     }
70852   }
70853
70854   jresult = (void *)result;
70855   return jresult;
70856 }
70857
70858
70859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
70860   void * jresult ;
70861   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70862   Dali::Toolkit::RadioButton *arg2 = 0 ;
70863   Dali::Toolkit::RadioButton *result = 0 ;
70864
70865   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70866   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
70867   if (!arg2) {
70868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70869     return 0;
70870   }
70871   {
70872     try {
70873       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
70874     } catch (std::out_of_range& e) {
70875       {
70876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70877       };
70878     } catch (std::exception& e) {
70879       {
70880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70881       };
70882     } catch (Dali::DaliException e) {
70883       {
70884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70885       };
70886     } catch (...) {
70887       {
70888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70889       };
70890     }
70891   }
70892
70893   jresult = (void *)result;
70894   return jresult;
70895 }
70896
70897
70898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70899   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70900
70901   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70902   {
70903     try {
70904       delete arg1;
70905     } catch (std::out_of_range& e) {
70906       {
70907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70908       };
70909     } catch (std::exception& e) {
70910       {
70911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70912       };
70913     } catch (Dali::DaliException e) {
70914       {
70915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70916       };
70917     } catch (...) {
70918       {
70919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70920       };
70921     }
70922   }
70923
70924 }
70925
70926
70927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70928   void * jresult ;
70929   Dali::Toolkit::RadioButton result;
70930
70931   {
70932     try {
70933       result = Dali::Toolkit::RadioButton::New();
70934     } catch (std::out_of_range& e) {
70935       {
70936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70937       };
70938     } catch (std::exception& e) {
70939       {
70940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70941       };
70942     } catch (Dali::DaliException e) {
70943       {
70944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70945       };
70946     } catch (...) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70949       };
70950     }
70951   }
70952
70953   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70954   return jresult;
70955 }
70956
70957
70958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70959   void * jresult ;
70960   std::string *arg1 = 0 ;
70961   Dali::Toolkit::RadioButton result;
70962
70963   if (!jarg1) {
70964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70965     return 0;
70966   }
70967   std::string arg1_str(jarg1);
70968   arg1 = &arg1_str;
70969   {
70970     try {
70971       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70972     } catch (std::out_of_range& e) {
70973       {
70974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70975       };
70976     } catch (std::exception& e) {
70977       {
70978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70979       };
70980     } catch (Dali::DaliException e) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70983       };
70984     } catch (...) {
70985       {
70986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70987       };
70988     }
70989   }
70990
70991   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70992
70993   //argout typemap for const std::string&
70994
70995   return jresult;
70996 }
70997
70998
70999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71000   void * jresult ;
71001   Dali::BaseHandle arg1 ;
71002   Dali::BaseHandle *argp1 ;
71003   Dali::Toolkit::RadioButton result;
71004
71005   argp1 = (Dali::BaseHandle *)jarg1;
71006   if (!argp1) {
71007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71008     return 0;
71009   }
71010   arg1 = *argp1;
71011   {
71012     try {
71013       result = Dali::Toolkit::RadioButton::DownCast(arg1);
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 = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71034   return jresult;
71035 }
71036
71037
71038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71039   int jresult ;
71040   int result;
71041
71042   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71043   jresult = (int)result;
71044   return jresult;
71045 }
71046
71047
71048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71049   int jresult ;
71050   int result;
71051
71052   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71053   jresult = (int)result;
71054   return jresult;
71055 }
71056
71057
71058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71059   int jresult ;
71060   int result;
71061
71062   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71063   jresult = (int)result;
71064   return jresult;
71065 }
71066
71067
71068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71069   int jresult ;
71070   int result;
71071
71072   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71073   jresult = (int)result;
71074   return jresult;
71075 }
71076
71077
71078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71079   int jresult ;
71080   int result;
71081
71082   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71083   jresult = (int)result;
71084   return jresult;
71085 }
71086
71087
71088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71089   int jresult ;
71090   int result;
71091
71092   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71093   jresult = (int)result;
71094   return jresult;
71095 }
71096
71097
71098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71099   void * jresult ;
71100   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71101
71102   {
71103     try {
71104       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71105     } catch (std::out_of_range& e) {
71106       {
71107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71108       };
71109     } catch (std::exception& e) {
71110       {
71111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71112       };
71113     } catch (Dali::DaliException e) {
71114       {
71115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71116       };
71117     } catch (...) {
71118       {
71119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71120       };
71121     }
71122   }
71123
71124   jresult = (void *)result;
71125   return jresult;
71126 }
71127
71128
71129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71130   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71131
71132   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71133   {
71134     try {
71135       delete arg1;
71136     } catch (std::out_of_range& e) {
71137       {
71138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71139       };
71140     } catch (std::exception& e) {
71141       {
71142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71143       };
71144     } catch (Dali::DaliException e) {
71145       {
71146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71147       };
71148     } catch (...) {
71149       {
71150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71151       };
71152     }
71153   }
71154
71155 }
71156
71157
71158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71159   int jresult ;
71160   int result;
71161
71162   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71163   jresult = (int)result;
71164   return jresult;
71165 }
71166
71167
71168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71169   int jresult ;
71170   int result;
71171
71172   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71173   jresult = (int)result;
71174   return jresult;
71175 }
71176
71177
71178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71179   int jresult ;
71180   int result;
71181
71182   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71183   jresult = (int)result;
71184   return jresult;
71185 }
71186
71187
71188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71189   void * jresult ;
71190   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71191
71192   {
71193     try {
71194       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71195     } catch (std::out_of_range& e) {
71196       {
71197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71198       };
71199     } catch (std::exception& e) {
71200       {
71201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71202       };
71203     } catch (Dali::DaliException e) {
71204       {
71205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71206       };
71207     } catch (...) {
71208       {
71209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71210       };
71211     }
71212   }
71213
71214   jresult = (void *)result;
71215   return jresult;
71216 }
71217
71218
71219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71220   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71221
71222   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71223   {
71224     try {
71225       delete arg1;
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_new_FlexContainer__SWIG_0() {
71249   void * jresult ;
71250   Dali::Toolkit::FlexContainer *result = 0 ;
71251
71252   {
71253     try {
71254       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71255     } catch (std::out_of_range& e) {
71256       {
71257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71258       };
71259     } catch (std::exception& e) {
71260       {
71261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71262       };
71263     } catch (Dali::DaliException e) {
71264       {
71265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71266       };
71267     } catch (...) {
71268       {
71269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71270       };
71271     }
71272   }
71273
71274   jresult = (void *)result;
71275   return jresult;
71276 }
71277
71278
71279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71280   void * jresult ;
71281   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71282   Dali::Toolkit::FlexContainer *result = 0 ;
71283
71284   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71285   if (!arg1) {
71286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71287     return 0;
71288   }
71289   {
71290     try {
71291       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71292     } catch (std::out_of_range& e) {
71293       {
71294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71295       };
71296     } catch (std::exception& e) {
71297       {
71298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71299       };
71300     } catch (Dali::DaliException e) {
71301       {
71302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71303       };
71304     } catch (...) {
71305       {
71306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71307       };
71308     }
71309   }
71310
71311   jresult = (void *)result;
71312   return jresult;
71313 }
71314
71315
71316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71317   void * jresult ;
71318   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71319   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71320   Dali::Toolkit::FlexContainer *result = 0 ;
71321
71322   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71323   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71324   if (!arg2) {
71325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71326     return 0;
71327   }
71328   {
71329     try {
71330       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71331     } catch (std::out_of_range& e) {
71332       {
71333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71334       };
71335     } catch (std::exception& e) {
71336       {
71337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71338       };
71339     } catch (Dali::DaliException e) {
71340       {
71341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71342       };
71343     } catch (...) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71346       };
71347     }
71348   }
71349
71350   jresult = (void *)result;
71351   return jresult;
71352 }
71353
71354
71355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71356   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71357
71358   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71359   {
71360     try {
71361       delete arg1;
71362     } catch (std::out_of_range& e) {
71363       {
71364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71365       };
71366     } catch (std::exception& e) {
71367       {
71368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71369       };
71370     } catch (Dali::DaliException e) {
71371       {
71372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71373       };
71374     } catch (...) {
71375       {
71376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71377       };
71378     }
71379   }
71380
71381 }
71382
71383
71384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71385   void * jresult ;
71386   Dali::Toolkit::FlexContainer result;
71387
71388   {
71389     try {
71390       result = Dali::Toolkit::FlexContainer::New();
71391     } catch (std::out_of_range& e) {
71392       {
71393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71394       };
71395     } catch (std::exception& e) {
71396       {
71397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71398       };
71399     } catch (Dali::DaliException e) {
71400       {
71401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71402       };
71403     } catch (...) {
71404       {
71405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71406       };
71407     }
71408   }
71409
71410   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71411   return jresult;
71412 }
71413
71414
71415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71416   void * jresult ;
71417   Dali::BaseHandle arg1 ;
71418   Dali::BaseHandle *argp1 ;
71419   Dali::Toolkit::FlexContainer result;
71420
71421   argp1 = (Dali::BaseHandle *)jarg1;
71422   if (!argp1) {
71423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71424     return 0;
71425   }
71426   arg1 = *argp1;
71427   {
71428     try {
71429       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71430     } catch (std::out_of_range& e) {
71431       {
71432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71433       };
71434     } catch (std::exception& e) {
71435       {
71436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71437       };
71438     } catch (Dali::DaliException e) {
71439       {
71440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71441       };
71442     } catch (...) {
71443       {
71444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71445       };
71446     }
71447   }
71448
71449   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71450   return jresult;
71451 }
71452
71453
71454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71455   int jresult ;
71456   int result;
71457
71458   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71459   jresult = (int)result;
71460   return jresult;
71461 }
71462
71463
71464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71465   int jresult ;
71466   int result;
71467
71468   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71469   jresult = (int)result;
71470   return jresult;
71471 }
71472
71473
71474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71475   int jresult ;
71476   int result;
71477
71478   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71479   jresult = (int)result;
71480   return jresult;
71481 }
71482
71483
71484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71485   int jresult ;
71486   int result;
71487
71488   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71489   jresult = (int)result;
71490   return jresult;
71491 }
71492
71493
71494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71495   void * jresult ;
71496   Dali::Toolkit::ImageView::Property *result = 0 ;
71497
71498   {
71499     try {
71500       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71501     } catch (std::out_of_range& e) {
71502       {
71503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71504       };
71505     } catch (std::exception& e) {
71506       {
71507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71508       };
71509     } catch (Dali::DaliException e) {
71510       {
71511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71512       };
71513     } catch (...) {
71514       {
71515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71516       };
71517     }
71518   }
71519
71520   jresult = (void *)result;
71521   return jresult;
71522 }
71523
71524
71525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71526   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71527
71528   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71529   {
71530     try {
71531       delete arg1;
71532     } catch (std::out_of_range& e) {
71533       {
71534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71535       };
71536     } catch (std::exception& e) {
71537       {
71538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71539       };
71540     } catch (Dali::DaliException e) {
71541       {
71542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71543       };
71544     } catch (...) {
71545       {
71546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71547       };
71548     }
71549   }
71550
71551 }
71552
71553
71554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71555   void * jresult ;
71556   Dali::Toolkit::ImageView *result = 0 ;
71557
71558   {
71559     try {
71560       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71561     } catch (std::out_of_range& e) {
71562       {
71563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71564       };
71565     } catch (std::exception& e) {
71566       {
71567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71568       };
71569     } catch (Dali::DaliException e) {
71570       {
71571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71572       };
71573     } catch (...) {
71574       {
71575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71576       };
71577     }
71578   }
71579
71580   jresult = (void *)result;
71581   return jresult;
71582 }
71583
71584
71585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71586   void * jresult ;
71587   Dali::Toolkit::ImageView result;
71588
71589   {
71590     try {
71591       result = Dali::Toolkit::ImageView::New();
71592     } catch (std::out_of_range& e) {
71593       {
71594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71595       };
71596     } catch (std::exception& e) {
71597       {
71598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71599       };
71600     } catch (Dali::DaliException e) {
71601       {
71602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71603       };
71604     } catch (...) {
71605       {
71606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71607       };
71608     }
71609   }
71610
71611   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71612   return jresult;
71613 }
71614
71615
71616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71617   void * jresult ;
71618   Dali::Image arg1 ;
71619   Dali::Image *argp1 ;
71620   Dali::Toolkit::ImageView result;
71621
71622   argp1 = (Dali::Image *)jarg1;
71623   if (!argp1) {
71624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71625     return 0;
71626   }
71627   arg1 = *argp1;
71628   {
71629     try {
71630       result = Dali::Toolkit::ImageView::New(arg1);
71631     } catch (std::out_of_range& e) {
71632       {
71633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71634       };
71635     } catch (std::exception& e) {
71636       {
71637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71638       };
71639     } catch (Dali::DaliException e) {
71640       {
71641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71642       };
71643     } catch (...) {
71644       {
71645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71646       };
71647     }
71648   }
71649
71650   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71651   return jresult;
71652 }
71653
71654
71655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71656   void * jresult ;
71657   std::string *arg1 = 0 ;
71658   Dali::Toolkit::ImageView result;
71659
71660   if (!jarg1) {
71661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71662     return 0;
71663   }
71664   std::string arg1_str(jarg1);
71665   arg1 = &arg1_str;
71666   {
71667     try {
71668       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71669     } catch (std::out_of_range& e) {
71670       {
71671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71672       };
71673     } catch (std::exception& e) {
71674       {
71675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71676       };
71677     } catch (Dali::DaliException e) {
71678       {
71679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71680       };
71681     } catch (...) {
71682       {
71683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71684       };
71685     }
71686   }
71687
71688   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71689
71690   //argout typemap for const std::string&
71691
71692   return jresult;
71693 }
71694
71695
71696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71697   void * jresult ;
71698   std::string *arg1 = 0 ;
71699   Dali::ImageDimensions arg2 ;
71700   Dali::ImageDimensions *argp2 ;
71701   Dali::Toolkit::ImageView result;
71702
71703   if (!jarg1) {
71704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71705     return 0;
71706   }
71707   std::string arg1_str(jarg1);
71708   arg1 = &arg1_str;
71709   argp2 = (Dali::ImageDimensions *)jarg2;
71710   if (!argp2) {
71711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71712     return 0;
71713   }
71714   arg2 = *argp2;
71715   {
71716     try {
71717       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71718     } catch (std::out_of_range& e) {
71719       {
71720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71721       };
71722     } catch (std::exception& e) {
71723       {
71724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71725       };
71726     } catch (Dali::DaliException e) {
71727       {
71728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71729       };
71730     } catch (...) {
71731       {
71732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71733       };
71734     }
71735   }
71736
71737   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71738
71739   //argout typemap for const std::string&
71740
71741   return jresult;
71742 }
71743
71744
71745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71746   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71747
71748   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71749   {
71750     try {
71751       delete arg1;
71752     } catch (std::out_of_range& e) {
71753       {
71754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71755       };
71756     } catch (std::exception& e) {
71757       {
71758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71759       };
71760     } catch (Dali::DaliException e) {
71761       {
71762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71763       };
71764     } catch (...) {
71765       {
71766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71767       };
71768     }
71769   }
71770
71771 }
71772
71773
71774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71775   void * jresult ;
71776   Dali::Toolkit::ImageView *arg1 = 0 ;
71777   Dali::Toolkit::ImageView *result = 0 ;
71778
71779   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71780   if (!arg1) {
71781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71782     return 0;
71783   }
71784   {
71785     try {
71786       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71787     } catch (std::out_of_range& e) {
71788       {
71789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71790       };
71791     } catch (std::exception& e) {
71792       {
71793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71794       };
71795     } catch (Dali::DaliException e) {
71796       {
71797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71798       };
71799     } catch (...) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71802       };
71803     }
71804   }
71805
71806   jresult = (void *)result;
71807   return jresult;
71808 }
71809
71810
71811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71812   void * jresult ;
71813   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71814   Dali::Toolkit::ImageView *arg2 = 0 ;
71815   Dali::Toolkit::ImageView *result = 0 ;
71816
71817   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71818   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71819   if (!arg2) {
71820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71821     return 0;
71822   }
71823   {
71824     try {
71825       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71826     } catch (std::out_of_range& e) {
71827       {
71828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71829       };
71830     } catch (std::exception& e) {
71831       {
71832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71833       };
71834     } catch (Dali::DaliException e) {
71835       {
71836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71837       };
71838     } catch (...) {
71839       {
71840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71841       };
71842     }
71843   }
71844
71845   jresult = (void *)result;
71846   return jresult;
71847 }
71848
71849
71850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
71851   void * jresult ;
71852   Dali::BaseHandle arg1 ;
71853   Dali::BaseHandle *argp1 ;
71854   Dali::Toolkit::ImageView result;
71855
71856   argp1 = (Dali::BaseHandle *)jarg1;
71857   if (!argp1) {
71858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71859     return 0;
71860   }
71861   arg1 = *argp1;
71862   {
71863     try {
71864       result = Dali::Toolkit::ImageView::DownCast(arg1);
71865     } catch (std::out_of_range& e) {
71866       {
71867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71868       };
71869     } catch (std::exception& e) {
71870       {
71871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71872       };
71873     } catch (Dali::DaliException e) {
71874       {
71875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71876       };
71877     } catch (...) {
71878       {
71879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71880       };
71881     }
71882   }
71883
71884   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71885   return jresult;
71886 }
71887
71888
71889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
71890   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71891   Dali::Image arg2 ;
71892   Dali::Image *argp2 ;
71893
71894   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71895   argp2 = (Dali::Image *)jarg2;
71896   if (!argp2) {
71897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71898     return ;
71899   }
71900   arg2 = *argp2;
71901   {
71902     try {
71903       (arg1)->SetImage(arg2);
71904     } catch (std::out_of_range& e) {
71905       {
71906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71907       };
71908     } catch (std::exception& e) {
71909       {
71910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71911       };
71912     } catch (Dali::DaliException e) {
71913       {
71914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71915       };
71916     } catch (...) {
71917       {
71918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71919       };
71920     }
71921   }
71922
71923 }
71924
71925
71926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71927   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71928   std::string *arg2 = 0 ;
71929
71930   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71931   if (!jarg2) {
71932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71933     return ;
71934   }
71935   std::string arg2_str(jarg2);
71936   arg2 = &arg2_str;
71937   {
71938     try {
71939       (arg1)->SetImage((std::string const &)*arg2);
71940     } catch (std::out_of_range& e) {
71941       {
71942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71943       };
71944     } catch (std::exception& e) {
71945       {
71946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71947       };
71948     } catch (Dali::DaliException e) {
71949       {
71950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71951       };
71952     } catch (...) {
71953       {
71954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71955       };
71956     }
71957   }
71958
71959
71960   //argout typemap for const std::string&
71961
71962 }
71963
71964
71965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71966   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71967   std::string *arg2 = 0 ;
71968   Dali::ImageDimensions arg3 ;
71969   Dali::ImageDimensions *argp3 ;
71970
71971   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71972   if (!jarg2) {
71973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71974     return ;
71975   }
71976   std::string arg2_str(jarg2);
71977   arg2 = &arg2_str;
71978   argp3 = (Dali::ImageDimensions *)jarg3;
71979   if (!argp3) {
71980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71981     return ;
71982   }
71983   arg3 = *argp3;
71984   {
71985     try {
71986       (arg1)->SetImage((std::string const &)*arg2,arg3);
71987     } catch (std::out_of_range& e) {
71988       {
71989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71990       };
71991     } catch (std::exception& e) {
71992       {
71993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71994       };
71995     } catch (Dali::DaliException e) {
71996       {
71997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71998       };
71999     } catch (...) {
72000       {
72001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72002       };
72003     }
72004   }
72005
72006
72007   //argout typemap for const std::string&
72008
72009 }
72010
72011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72012   void * jresult ;
72013   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72014   Dali::Image result;
72015
72016   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72017   {
72018     try {
72019       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72020     } catch (std::out_of_range& e) {
72021       {
72022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72023       };
72024     } catch (std::exception& e) {
72025       {
72026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72027       };
72028     } catch (Dali::DaliException e) {
72029       {
72030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72031       };
72032     } catch (...) {
72033       {
72034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72035       };
72036     }
72037   }
72038
72039   jresult = new Dali::Image((const Dali::Image &)result);
72040   return jresult;
72041 }
72042
72043
72044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72045   int jresult ;
72046   int result;
72047
72048   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72049   jresult = (int)result;
72050   return jresult;
72051 }
72052
72053
72054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72055   int jresult ;
72056   int result;
72057
72058   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72059   jresult = (int)result;
72060   return jresult;
72061 }
72062
72063
72064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72065   int jresult ;
72066   int result;
72067
72068   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72069   jresult = (int)result;
72070   return jresult;
72071 }
72072
72073
72074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72075   int jresult ;
72076   int result;
72077
72078   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72079   jresult = (int)result;
72080   return jresult;
72081 }
72082
72083
72084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72085   int jresult ;
72086   int result;
72087
72088   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72089   jresult = (int)result;
72090   return jresult;
72091 }
72092
72093
72094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72095   int jresult ;
72096   int result;
72097
72098   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72099   jresult = (int)result;
72100   return jresult;
72101 }
72102
72103
72104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72105   int jresult ;
72106   int result;
72107
72108   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72109   jresult = (int)result;
72110   return jresult;
72111 }
72112
72113
72114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72115   int jresult ;
72116   int result;
72117
72118   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72119   jresult = (int)result;
72120   return jresult;
72121 }
72122
72123
72124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72125   void * jresult ;
72126   Dali::Toolkit::Model3dView::Property *result = 0 ;
72127
72128   {
72129     try {
72130       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72131     } catch (std::out_of_range& e) {
72132       {
72133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72134       };
72135     } catch (std::exception& e) {
72136       {
72137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72138       };
72139     } catch (Dali::DaliException e) {
72140       {
72141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72142       };
72143     } catch (...) {
72144       {
72145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72146       };
72147     }
72148   }
72149
72150   jresult = (void *)result;
72151   return jresult;
72152 }
72153
72154
72155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72156   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72157
72158   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72159   {
72160     try {
72161       delete arg1;
72162     } catch (std::out_of_range& e) {
72163       {
72164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72165       };
72166     } catch (std::exception& e) {
72167       {
72168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72169       };
72170     } catch (Dali::DaliException e) {
72171       {
72172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72173       };
72174     } catch (...) {
72175       {
72176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72177       };
72178     }
72179   }
72180
72181 }
72182
72183
72184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72185   void * jresult ;
72186   Dali::Toolkit::Model3dView result;
72187
72188   {
72189     try {
72190       result = Dali::Toolkit::Model3dView::New();
72191     } catch (std::out_of_range& e) {
72192       {
72193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72194       };
72195     } catch (std::exception& e) {
72196       {
72197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72198       };
72199     } catch (Dali::DaliException e) {
72200       {
72201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72202       };
72203     } catch (...) {
72204       {
72205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72206       };
72207     }
72208   }
72209
72210   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72211   return jresult;
72212 }
72213
72214
72215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72216   void * jresult ;
72217   std::string *arg1 = 0 ;
72218   std::string *arg2 = 0 ;
72219   std::string *arg3 = 0 ;
72220   Dali::Toolkit::Model3dView result;
72221
72222   if (!jarg1) {
72223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72224     return 0;
72225   }
72226   std::string arg1_str(jarg1);
72227   arg1 = &arg1_str;
72228   if (!jarg2) {
72229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72230     return 0;
72231   }
72232   std::string arg2_str(jarg2);
72233   arg2 = &arg2_str;
72234   if (!jarg3) {
72235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72236     return 0;
72237   }
72238   std::string arg3_str(jarg3);
72239   arg3 = &arg3_str;
72240   {
72241     try {
72242       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72243     } catch (std::out_of_range& e) {
72244       {
72245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72246       };
72247     } catch (std::exception& e) {
72248       {
72249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72250       };
72251     } catch (Dali::DaliException e) {
72252       {
72253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72254       };
72255     } catch (...) {
72256       {
72257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72258       };
72259     }
72260   }
72261
72262   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72263
72264   //argout typemap for const std::string&
72265
72266
72267   //argout typemap for const std::string&
72268
72269
72270   //argout typemap for const std::string&
72271
72272   return jresult;
72273 }
72274
72275
72276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72277   void * jresult ;
72278   Dali::Toolkit::Model3dView *result = 0 ;
72279
72280   {
72281     try {
72282       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72283     } catch (std::out_of_range& e) {
72284       {
72285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72286       };
72287     } catch (std::exception& e) {
72288       {
72289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72290       };
72291     } catch (Dali::DaliException e) {
72292       {
72293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72294       };
72295     } catch (...) {
72296       {
72297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72298       };
72299     }
72300   }
72301
72302   jresult = (void *)result;
72303   return jresult;
72304 }
72305
72306
72307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72308   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72309
72310   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72311   {
72312     try {
72313       delete arg1;
72314     } catch (std::out_of_range& e) {
72315       {
72316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72317       };
72318     } catch (std::exception& e) {
72319       {
72320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72321       };
72322     } catch (Dali::DaliException e) {
72323       {
72324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72325       };
72326     } catch (...) {
72327       {
72328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72329       };
72330     }
72331   }
72332
72333 }
72334
72335
72336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72337   void * jresult ;
72338   Dali::Toolkit::Model3dView *arg1 = 0 ;
72339   Dali::Toolkit::Model3dView *result = 0 ;
72340
72341   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72342   if (!arg1) {
72343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72344     return 0;
72345   }
72346   {
72347     try {
72348       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72349     } catch (std::out_of_range& e) {
72350       {
72351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72352       };
72353     } catch (std::exception& e) {
72354       {
72355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72356       };
72357     } catch (Dali::DaliException e) {
72358       {
72359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72360       };
72361     } catch (...) {
72362       {
72363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72364       };
72365     }
72366   }
72367
72368   jresult = (void *)result;
72369   return jresult;
72370 }
72371
72372
72373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72374   void * jresult ;
72375   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72376   Dali::Toolkit::Model3dView *arg2 = 0 ;
72377   Dali::Toolkit::Model3dView *result = 0 ;
72378
72379   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72380   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72381   if (!arg2) {
72382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72383     return 0;
72384   }
72385   {
72386     try {
72387       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72388     } catch (std::out_of_range& e) {
72389       {
72390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72391       };
72392     } catch (std::exception& e) {
72393       {
72394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72395       };
72396     } catch (Dali::DaliException e) {
72397       {
72398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72399       };
72400     } catch (...) {
72401       {
72402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72403       };
72404     }
72405   }
72406
72407   jresult = (void *)result;
72408   return jresult;
72409 }
72410
72411
72412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72413   void * jresult ;
72414   Dali::BaseHandle arg1 ;
72415   Dali::BaseHandle *argp1 ;
72416   Dali::Toolkit::Model3dView result;
72417
72418   argp1 = (Dali::BaseHandle *)jarg1;
72419   if (!argp1) {
72420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72421     return 0;
72422   }
72423   arg1 = *argp1;
72424   {
72425     try {
72426       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72427     } catch (std::out_of_range& e) {
72428       {
72429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72430       };
72431     } catch (std::exception& e) {
72432       {
72433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72434       };
72435     } catch (Dali::DaliException e) {
72436       {
72437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72438       };
72439     } catch (...) {
72440       {
72441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72442       };
72443     }
72444   }
72445
72446   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72447   return jresult;
72448 }
72449
72450
72451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72452   int jresult ;
72453   int result;
72454
72455   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72456   jresult = (int)result;
72457   return jresult;
72458 }
72459
72460
72461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72462   int jresult ;
72463   int result;
72464
72465   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72466   jresult = (int)result;
72467   return jresult;
72468 }
72469
72470
72471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72472   int jresult ;
72473   int result;
72474
72475   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72476   jresult = (int)result;
72477   return jresult;
72478 }
72479
72480
72481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72482   int jresult ;
72483   int result;
72484
72485   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72486   jresult = (int)result;
72487   return jresult;
72488 }
72489
72490
72491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72492   int jresult ;
72493   int result;
72494
72495   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72496   jresult = (int)result;
72497   return jresult;
72498 }
72499
72500
72501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72502   int jresult ;
72503   int result;
72504
72505   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72506   jresult = (int)result;
72507   return jresult;
72508 }
72509
72510
72511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72512   int jresult ;
72513   int result;
72514
72515   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72516   jresult = (int)result;
72517   return jresult;
72518 }
72519
72520
72521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72522   int jresult ;
72523   int result;
72524
72525   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72526   jresult = (int)result;
72527   return jresult;
72528 }
72529
72530
72531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72532   int jresult ;
72533   int result;
72534
72535   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72536   jresult = (int)result;
72537   return jresult;
72538 }
72539
72540
72541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72542   void * jresult ;
72543   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72544
72545   {
72546     try {
72547       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72548     } catch (std::out_of_range& e) {
72549       {
72550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72551       };
72552     } catch (std::exception& e) {
72553       {
72554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72555       };
72556     } catch (Dali::DaliException e) {
72557       {
72558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72559       };
72560     } catch (...) {
72561       {
72562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72563       };
72564     }
72565   }
72566
72567   jresult = (void *)result;
72568   return jresult;
72569 }
72570
72571
72572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72573   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72574
72575   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72576   {
72577     try {
72578       delete arg1;
72579     } catch (std::out_of_range& e) {
72580       {
72581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72582       };
72583     } catch (std::exception& e) {
72584       {
72585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72586       };
72587     } catch (Dali::DaliException e) {
72588       {
72589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72590       };
72591     } catch (...) {
72592       {
72593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72594       };
72595     }
72596   }
72597
72598 }
72599
72600
72601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72602   void * jresult ;
72603   Dali::Toolkit::ScrollBar *result = 0 ;
72604
72605   {
72606     try {
72607       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72608     } catch (std::out_of_range& e) {
72609       {
72610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72611       };
72612     } catch (std::exception& e) {
72613       {
72614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72615       };
72616     } catch (Dali::DaliException e) {
72617       {
72618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72619       };
72620     } catch (...) {
72621       {
72622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72623       };
72624     }
72625   }
72626
72627   jresult = (void *)result;
72628   return jresult;
72629 }
72630
72631
72632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72633   void * jresult ;
72634   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72635   Dali::Toolkit::ScrollBar *result = 0 ;
72636
72637   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72638   if (!arg1) {
72639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72640     return 0;
72641   }
72642   {
72643     try {
72644       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72645     } catch (std::out_of_range& e) {
72646       {
72647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72648       };
72649     } catch (std::exception& e) {
72650       {
72651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72652       };
72653     } catch (Dali::DaliException e) {
72654       {
72655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72656       };
72657     } catch (...) {
72658       {
72659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72660       };
72661     }
72662   }
72663
72664   jresult = (void *)result;
72665   return jresult;
72666 }
72667
72668
72669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72670   void * jresult ;
72671   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72672   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72673   Dali::Toolkit::ScrollBar *result = 0 ;
72674
72675   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72676   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72677   if (!arg2) {
72678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72679     return 0;
72680   }
72681   {
72682     try {
72683       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72684     } catch (std::out_of_range& e) {
72685       {
72686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72687       };
72688     } catch (std::exception& e) {
72689       {
72690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72691       };
72692     } catch (Dali::DaliException e) {
72693       {
72694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72695       };
72696     } catch (...) {
72697       {
72698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72699       };
72700     }
72701   }
72702
72703   jresult = (void *)result;
72704   return jresult;
72705 }
72706
72707
72708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72709   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72710
72711   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72712   {
72713     try {
72714       delete arg1;
72715     } catch (std::out_of_range& e) {
72716       {
72717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72718       };
72719     } catch (std::exception& e) {
72720       {
72721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72722       };
72723     } catch (Dali::DaliException e) {
72724       {
72725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72726       };
72727     } catch (...) {
72728       {
72729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72730       };
72731     }
72732   }
72733
72734 }
72735
72736
72737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72738   void * jresult ;
72739   Dali::Toolkit::ScrollBar::Direction arg1 ;
72740   Dali::Toolkit::ScrollBar result;
72741
72742   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72743   {
72744     try {
72745       result = Dali::Toolkit::ScrollBar::New(arg1);
72746     } catch (std::out_of_range& e) {
72747       {
72748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72749       };
72750     } catch (std::exception& e) {
72751       {
72752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72753       };
72754     } catch (Dali::DaliException e) {
72755       {
72756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72757       };
72758     } catch (...) {
72759       {
72760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72761       };
72762     }
72763   }
72764
72765   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72766   return jresult;
72767 }
72768
72769
72770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72771   void * jresult ;
72772   Dali::Toolkit::ScrollBar result;
72773
72774   {
72775     try {
72776       result = Dali::Toolkit::ScrollBar::New();
72777     } catch (std::out_of_range& e) {
72778       {
72779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72780       };
72781     } catch (std::exception& e) {
72782       {
72783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72784       };
72785     } catch (Dali::DaliException e) {
72786       {
72787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72788       };
72789     } catch (...) {
72790       {
72791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72792       };
72793     }
72794   }
72795
72796   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72797   return jresult;
72798 }
72799
72800
72801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72802   void * jresult ;
72803   Dali::BaseHandle arg1 ;
72804   Dali::BaseHandle *argp1 ;
72805   Dali::Toolkit::ScrollBar result;
72806
72807   argp1 = (Dali::BaseHandle *)jarg1;
72808   if (!argp1) {
72809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72810     return 0;
72811   }
72812   arg1 = *argp1;
72813   {
72814     try {
72815       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72816     } catch (std::out_of_range& e) {
72817       {
72818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72819       };
72820     } catch (std::exception& e) {
72821       {
72822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72823       };
72824     } catch (Dali::DaliException e) {
72825       {
72826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72827       };
72828     } catch (...) {
72829       {
72830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72831       };
72832     }
72833   }
72834
72835   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72836   return jresult;
72837 }
72838
72839
72840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
72841   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72842   Dali::Handle arg2 ;
72843   Dali::Property::Index arg3 ;
72844   Dali::Property::Index arg4 ;
72845   Dali::Property::Index arg5 ;
72846   Dali::Property::Index arg6 ;
72847   Dali::Handle *argp2 ;
72848
72849   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72850   argp2 = (Dali::Handle *)jarg2;
72851   if (!argp2) {
72852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
72853     return ;
72854   }
72855   arg2 = *argp2;
72856   arg3 = (Dali::Property::Index)jarg3;
72857   arg4 = (Dali::Property::Index)jarg4;
72858   arg5 = (Dali::Property::Index)jarg5;
72859   arg6 = (Dali::Property::Index)jarg6;
72860   {
72861     try {
72862       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
72863     } catch (std::out_of_range& e) {
72864       {
72865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72866       };
72867     } catch (std::exception& e) {
72868       {
72869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72870       };
72871     } catch (Dali::DaliException e) {
72872       {
72873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72874       };
72875     } catch (...) {
72876       {
72877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72878       };
72879     }
72880   }
72881
72882 }
72883
72884
72885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
72886   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72887   Dali::Actor arg2 ;
72888   Dali::Actor *argp2 ;
72889
72890   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72891   argp2 = (Dali::Actor *)jarg2;
72892   if (!argp2) {
72893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72894     return ;
72895   }
72896   arg2 = *argp2;
72897   {
72898     try {
72899       (arg1)->SetScrollIndicator(arg2);
72900     } catch (std::out_of_range& e) {
72901       {
72902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72903       };
72904     } catch (std::exception& e) {
72905       {
72906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72907       };
72908     } catch (Dali::DaliException e) {
72909       {
72910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72911       };
72912     } catch (...) {
72913       {
72914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72915       };
72916     }
72917   }
72918
72919 }
72920
72921
72922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72923   void * jresult ;
72924   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72925   Dali::Actor result;
72926
72927   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72928   {
72929     try {
72930       result = (arg1)->GetScrollIndicator();
72931     } catch (std::out_of_range& e) {
72932       {
72933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72934       };
72935     } catch (std::exception& e) {
72936       {
72937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72938       };
72939     } catch (Dali::DaliException e) {
72940       {
72941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72942       };
72943     } catch (...) {
72944       {
72945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72946       };
72947     }
72948   }
72949
72950   jresult = new Dali::Actor((const Dali::Actor &)result);
72951   return jresult;
72952 }
72953
72954
72955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72956   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72957   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72958
72959   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72960   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72961   if (!arg2) {
72962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72963     return ;
72964   }
72965   {
72966     try {
72967       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72968     } catch (std::out_of_range& e) {
72969       {
72970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72971       };
72972     } catch (std::exception& e) {
72973       {
72974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72975       };
72976     } catch (Dali::DaliException e) {
72977       {
72978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72979       };
72980     } catch (...) {
72981       {
72982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72983       };
72984     }
72985   }
72986
72987 }
72988
72989
72990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72991   void * jresult ;
72992   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72993
72994   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72995   {
72996     try {
72997       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()));
72998     } catch (std::out_of_range& e) {
72999       {
73000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73001       };
73002     } catch (std::exception& e) {
73003       {
73004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73005       };
73006     } catch (...) {
73007       {
73008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73009       };
73010     }
73011   }
73012   return jresult;
73013 }
73014
73015
73016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73017   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73018   Dali::Toolkit::ScrollBar::Direction arg2 ;
73019
73020   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73021   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73022   {
73023     try {
73024       (arg1)->SetScrollDirection(arg2);
73025     } catch (std::out_of_range& e) {
73026       {
73027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73028       };
73029     } catch (std::exception& e) {
73030       {
73031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73032       };
73033     } catch (Dali::DaliException e) {
73034       {
73035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73036       };
73037     } catch (...) {
73038       {
73039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73040       };
73041     }
73042   }
73043
73044 }
73045
73046
73047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73048   int jresult ;
73049   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73050   Dali::Toolkit::ScrollBar::Direction result;
73051
73052   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73053   {
73054     try {
73055       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73056     } catch (std::out_of_range& e) {
73057       {
73058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73059       };
73060     } catch (std::exception& e) {
73061       {
73062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73063       };
73064     } catch (Dali::DaliException e) {
73065       {
73066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73067       };
73068     } catch (...) {
73069       {
73070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73071       };
73072     }
73073   }
73074
73075   jresult = (int)result;
73076   return jresult;
73077 }
73078
73079
73080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73081   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73082   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73083
73084   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73085   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73086   {
73087     try {
73088       (arg1)->SetIndicatorHeightPolicy(arg2);
73089     } catch (std::out_of_range& e) {
73090       {
73091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73092       };
73093     } catch (std::exception& e) {
73094       {
73095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73096       };
73097     } catch (Dali::DaliException e) {
73098       {
73099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73100       };
73101     } catch (...) {
73102       {
73103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73104       };
73105     }
73106   }
73107
73108 }
73109
73110
73111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73112   int jresult ;
73113   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73114   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73115
73116   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73117   {
73118     try {
73119       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73120     } catch (std::out_of_range& e) {
73121       {
73122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73123       };
73124     } catch (std::exception& e) {
73125       {
73126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73127       };
73128     } catch (Dali::DaliException e) {
73129       {
73130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73131       };
73132     } catch (...) {
73133       {
73134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73135       };
73136     }
73137   }
73138
73139   jresult = (int)result;
73140   return jresult;
73141 }
73142
73143
73144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73145   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73146   float arg2 ;
73147
73148   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73149   arg2 = (float)jarg2;
73150   {
73151     try {
73152       (arg1)->SetIndicatorFixedHeight(arg2);
73153     } catch (std::out_of_range& e) {
73154       {
73155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73156       };
73157     } catch (std::exception& e) {
73158       {
73159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73160       };
73161     } catch (Dali::DaliException e) {
73162       {
73163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73164       };
73165     } catch (...) {
73166       {
73167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73168       };
73169     }
73170   }
73171
73172 }
73173
73174
73175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73176   float jresult ;
73177   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73178   float result;
73179
73180   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73181   {
73182     try {
73183       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73184     } catch (std::out_of_range& e) {
73185       {
73186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73187       };
73188     } catch (std::exception& e) {
73189       {
73190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73191       };
73192     } catch (Dali::DaliException e) {
73193       {
73194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73195       };
73196     } catch (...) {
73197       {
73198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73199       };
73200     }
73201   }
73202
73203   jresult = result;
73204   return jresult;
73205 }
73206
73207
73208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73209   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73210   float arg2 ;
73211
73212   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73213   arg2 = (float)jarg2;
73214   {
73215     try {
73216       (arg1)->SetIndicatorShowDuration(arg2);
73217     } catch (std::out_of_range& e) {
73218       {
73219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73220       };
73221     } catch (std::exception& e) {
73222       {
73223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73224       };
73225     } catch (Dali::DaliException e) {
73226       {
73227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73228       };
73229     } catch (...) {
73230       {
73231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73232       };
73233     }
73234   }
73235
73236 }
73237
73238
73239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73240   float jresult ;
73241   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73242   float result;
73243
73244   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73245   {
73246     try {
73247       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73248     } catch (std::out_of_range& e) {
73249       {
73250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73251       };
73252     } catch (std::exception& e) {
73253       {
73254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73255       };
73256     } catch (Dali::DaliException e) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73259       };
73260     } catch (...) {
73261       {
73262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73263       };
73264     }
73265   }
73266
73267   jresult = result;
73268   return jresult;
73269 }
73270
73271
73272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73273   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73274   float arg2 ;
73275
73276   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73277   arg2 = (float)jarg2;
73278   {
73279     try {
73280       (arg1)->SetIndicatorHideDuration(arg2);
73281     } catch (std::out_of_range& e) {
73282       {
73283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73284       };
73285     } catch (std::exception& e) {
73286       {
73287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73288       };
73289     } catch (Dali::DaliException e) {
73290       {
73291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73292       };
73293     } catch (...) {
73294       {
73295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73296       };
73297     }
73298   }
73299
73300 }
73301
73302
73303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73304   float jresult ;
73305   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73306   float result;
73307
73308   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73309   {
73310     try {
73311       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73312     } catch (std::out_of_range& e) {
73313       {
73314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73315       };
73316     } catch (std::exception& e) {
73317       {
73318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73319       };
73320     } catch (Dali::DaliException e) {
73321       {
73322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73323       };
73324     } catch (...) {
73325       {
73326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73327       };
73328     }
73329   }
73330
73331   jresult = result;
73332   return jresult;
73333 }
73334
73335
73336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73337   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73338
73339   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73340   {
73341     try {
73342       (arg1)->ShowIndicator();
73343     } catch (std::out_of_range& e) {
73344       {
73345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73346       };
73347     } catch (std::exception& e) {
73348       {
73349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73350       };
73351     } catch (Dali::DaliException e) {
73352       {
73353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73354       };
73355     } catch (...) {
73356       {
73357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73358       };
73359     }
73360   }
73361
73362 }
73363
73364
73365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73366   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73367
73368   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73369   {
73370     try {
73371       (arg1)->HideIndicator();
73372     } catch (std::out_of_range& e) {
73373       {
73374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73375       };
73376     } catch (std::exception& e) {
73377       {
73378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73379       };
73380     } catch (Dali::DaliException e) {
73381       {
73382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73383       };
73384     } catch (...) {
73385       {
73386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73387       };
73388     }
73389   }
73390
73391 }
73392
73393
73394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73395   void * jresult ;
73396   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73397   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73398
73399   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73400   {
73401     try {
73402       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73403     } catch (std::out_of_range& e) {
73404       {
73405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73406       };
73407     } catch (std::exception& e) {
73408       {
73409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73410       };
73411     } catch (Dali::DaliException e) {
73412       {
73413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73414       };
73415     } catch (...) {
73416       {
73417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73418       };
73419     }
73420   }
73421
73422   jresult = (void *)result;
73423   return jresult;
73424 }
73425
73426
73427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73428   void * jresult ;
73429   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73430   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73431
73432   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73433   {
73434     try {
73435       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73436     } catch (std::out_of_range& e) {
73437       {
73438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73439       };
73440     } catch (std::exception& e) {
73441       {
73442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73443       };
73444     } catch (Dali::DaliException e) {
73445       {
73446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73447       };
73448     } catch (...) {
73449       {
73450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73451       };
73452     }
73453   }
73454
73455   jresult = (void *)result;
73456   return jresult;
73457 }
73458
73459
73460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73461   int jresult ;
73462   int result;
73463
73464   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73465   jresult = (int)result;
73466   return jresult;
73467 }
73468
73469
73470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73471   int jresult ;
73472   int result;
73473
73474   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73475   jresult = (int)result;
73476   return jresult;
73477 }
73478
73479
73480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73481   int jresult ;
73482   int result;
73483
73484   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73485   jresult = (int)result;
73486   return jresult;
73487 }
73488
73489
73490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73491   int jresult ;
73492   int result;
73493
73494   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73495   jresult = (int)result;
73496   return jresult;
73497 }
73498
73499
73500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73501   int jresult ;
73502   int result;
73503
73504   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73505   jresult = (int)result;
73506   return jresult;
73507 }
73508
73509
73510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73511   int jresult ;
73512   int result;
73513
73514   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73515   jresult = (int)result;
73516   return jresult;
73517 }
73518
73519
73520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73521   int jresult ;
73522   int result;
73523
73524   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73525   jresult = (int)result;
73526   return jresult;
73527 }
73528
73529
73530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73531   int jresult ;
73532   int result;
73533
73534   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73535   jresult = (int)result;
73536   return jresult;
73537 }
73538
73539
73540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73541   int jresult ;
73542   int result;
73543
73544   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73545   jresult = (int)result;
73546   return jresult;
73547 }
73548
73549
73550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73551   int jresult ;
73552   int result;
73553
73554   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73555   jresult = (int)result;
73556   return jresult;
73557 }
73558
73559
73560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73561   int jresult ;
73562   int result;
73563
73564   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73565   jresult = (int)result;
73566   return jresult;
73567 }
73568
73569
73570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73571   int jresult ;
73572   int result;
73573
73574   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73575   jresult = (int)result;
73576   return jresult;
73577 }
73578
73579
73580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73581   int jresult ;
73582   int result;
73583
73584   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73585   jresult = (int)result;
73586   return jresult;
73587 }
73588
73589
73590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73591   int jresult ;
73592   int result;
73593
73594   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73595   jresult = (int)result;
73596   return jresult;
73597 }
73598
73599
73600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73601   void * jresult ;
73602   Dali::Toolkit::Scrollable::Property *result = 0 ;
73603
73604   {
73605     try {
73606       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73607     } catch (std::out_of_range& e) {
73608       {
73609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73610       };
73611     } catch (std::exception& e) {
73612       {
73613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73614       };
73615     } catch (Dali::DaliException e) {
73616       {
73617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73618       };
73619     } catch (...) {
73620       {
73621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73622       };
73623     }
73624   }
73625
73626   jresult = (void *)result;
73627   return jresult;
73628 }
73629
73630
73631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73632   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73633
73634   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73635   {
73636     try {
73637       delete arg1;
73638     } catch (std::out_of_range& e) {
73639       {
73640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73641       };
73642     } catch (std::exception& e) {
73643       {
73644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73645       };
73646     } catch (Dali::DaliException e) {
73647       {
73648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73649       };
73650     } catch (...) {
73651       {
73652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73653       };
73654     }
73655   }
73656
73657 }
73658
73659
73660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73661   void * jresult ;
73662   Dali::Toolkit::Scrollable *result = 0 ;
73663
73664   {
73665     try {
73666       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73667     } catch (std::out_of_range& e) {
73668       {
73669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73670       };
73671     } catch (std::exception& e) {
73672       {
73673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73674       };
73675     } catch (Dali::DaliException e) {
73676       {
73677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73678       };
73679     } catch (...) {
73680       {
73681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73682       };
73683     }
73684   }
73685
73686   jresult = (void *)result;
73687   return jresult;
73688 }
73689
73690
73691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73692   void * jresult ;
73693   Dali::Toolkit::Scrollable *arg1 = 0 ;
73694   Dali::Toolkit::Scrollable *result = 0 ;
73695
73696   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73697   if (!arg1) {
73698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73699     return 0;
73700   }
73701   {
73702     try {
73703       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73704     } catch (std::out_of_range& e) {
73705       {
73706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73707       };
73708     } catch (std::exception& e) {
73709       {
73710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73711       };
73712     } catch (Dali::DaliException e) {
73713       {
73714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73715       };
73716     } catch (...) {
73717       {
73718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73719       };
73720     }
73721   }
73722
73723   jresult = (void *)result;
73724   return jresult;
73725 }
73726
73727
73728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73729   void * jresult ;
73730   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73731   Dali::Toolkit::Scrollable *arg2 = 0 ;
73732   Dali::Toolkit::Scrollable *result = 0 ;
73733
73734   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73735   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73736   if (!arg2) {
73737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73738     return 0;
73739   }
73740   {
73741     try {
73742       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73743     } catch (std::out_of_range& e) {
73744       {
73745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73746       };
73747     } catch (std::exception& e) {
73748       {
73749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73750       };
73751     } catch (Dali::DaliException e) {
73752       {
73753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73754       };
73755     } catch (...) {
73756       {
73757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73758       };
73759     }
73760   }
73761
73762   jresult = (void *)result;
73763   return jresult;
73764 }
73765
73766
73767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73768   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73769
73770   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73771   {
73772     try {
73773       delete arg1;
73774     } catch (std::out_of_range& e) {
73775       {
73776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73777       };
73778     } catch (std::exception& e) {
73779       {
73780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73781       };
73782     } catch (Dali::DaliException e) {
73783       {
73784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73785       };
73786     } catch (...) {
73787       {
73788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73789       };
73790     }
73791   }
73792
73793 }
73794
73795
73796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73797   void * jresult ;
73798   Dali::BaseHandle arg1 ;
73799   Dali::BaseHandle *argp1 ;
73800   Dali::Toolkit::Scrollable result;
73801
73802   argp1 = (Dali::BaseHandle *)jarg1;
73803   if (!argp1) {
73804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73805     return 0;
73806   }
73807   arg1 = *argp1;
73808   {
73809     try {
73810       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73811     } catch (std::out_of_range& e) {
73812       {
73813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73814       };
73815     } catch (std::exception& e) {
73816       {
73817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73818       };
73819     } catch (Dali::DaliException e) {
73820       {
73821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73822       };
73823     } catch (...) {
73824       {
73825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73826       };
73827     }
73828   }
73829
73830   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73831   return jresult;
73832 }
73833
73834
73835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
73836   unsigned int jresult ;
73837   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73838   bool result;
73839
73840   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73841   {
73842     try {
73843       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
73844     } catch (std::out_of_range& e) {
73845       {
73846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73847       };
73848     } catch (std::exception& e) {
73849       {
73850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73851       };
73852     } catch (Dali::DaliException e) {
73853       {
73854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73855       };
73856     } catch (...) {
73857       {
73858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73859       };
73860     }
73861   }
73862
73863   jresult = result;
73864   return jresult;
73865 }
73866
73867
73868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
73869   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73870   bool arg2 ;
73871
73872   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73873   arg2 = jarg2 ? true : false;
73874   {
73875     try {
73876       (arg1)->SetOvershootEnabled(arg2);
73877     } catch (std::out_of_range& e) {
73878       {
73879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73880       };
73881     } catch (std::exception& e) {
73882       {
73883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73884       };
73885     } catch (Dali::DaliException e) {
73886       {
73887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73888       };
73889     } catch (...) {
73890       {
73891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73892       };
73893     }
73894   }
73895
73896 }
73897
73898
73899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73900   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73901   Dali::Vector4 *arg2 = 0 ;
73902
73903   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73904   arg2 = (Dali::Vector4 *)jarg2;
73905   if (!arg2) {
73906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73907     return ;
73908   }
73909   {
73910     try {
73911       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73912     } catch (std::out_of_range& e) {
73913       {
73914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73915       };
73916     } catch (std::exception& e) {
73917       {
73918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73919       };
73920     } catch (Dali::DaliException e) {
73921       {
73922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73923       };
73924     } catch (...) {
73925       {
73926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73927       };
73928     }
73929   }
73930
73931 }
73932
73933
73934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73935   void * jresult ;
73936   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73937   Dali::Vector4 result;
73938
73939   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73940   {
73941     try {
73942       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73943     } catch (std::out_of_range& e) {
73944       {
73945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73946       };
73947     } catch (std::exception& e) {
73948       {
73949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73950       };
73951     } catch (Dali::DaliException e) {
73952       {
73953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73954       };
73955     } catch (...) {
73956       {
73957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73958       };
73959     }
73960   }
73961
73962   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73963   return jresult;
73964 }
73965
73966
73967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73968   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73969   float arg2 ;
73970
73971   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73972   arg2 = (float)jarg2;
73973   {
73974     try {
73975       (arg1)->SetOvershootAnimationSpeed(arg2);
73976     } catch (std::out_of_range& e) {
73977       {
73978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73979       };
73980     } catch (std::exception& e) {
73981       {
73982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73983       };
73984     } catch (Dali::DaliException e) {
73985       {
73986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73987       };
73988     } catch (...) {
73989       {
73990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73991       };
73992     }
73993   }
73994
73995 }
73996
73997
73998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73999   float jresult ;
74000   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74001   float result;
74002
74003   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74004   {
74005     try {
74006       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74007     } catch (std::out_of_range& e) {
74008       {
74009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74010       };
74011     } catch (std::exception& e) {
74012       {
74013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74014       };
74015     } catch (Dali::DaliException e) {
74016       {
74017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74018       };
74019     } catch (...) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74022       };
74023     }
74024   }
74025
74026   jresult = result;
74027   return jresult;
74028 }
74029
74030
74031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74032   void * jresult ;
74033   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74034   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74035
74036   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74037   {
74038     try {
74039       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74040     } catch (std::out_of_range& e) {
74041       {
74042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74043       };
74044     } catch (std::exception& e) {
74045       {
74046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74047       };
74048     } catch (Dali::DaliException e) {
74049       {
74050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74051       };
74052     } catch (...) {
74053       {
74054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74055       };
74056     }
74057   }
74058
74059   jresult = (void *)result;
74060   return jresult;
74061 }
74062
74063
74064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74065   void * jresult ;
74066   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74067   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74068
74069   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74070   {
74071     try {
74072       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74073     } catch (std::out_of_range& e) {
74074       {
74075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74076       };
74077     } catch (std::exception& e) {
74078       {
74079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74080       };
74081     } catch (Dali::DaliException e) {
74082       {
74083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74084       };
74085     } catch (...) {
74086       {
74087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74088       };
74089     }
74090   }
74091
74092   jresult = (void *)result;
74093   return jresult;
74094 }
74095
74096
74097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74098   void * jresult ;
74099   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74100   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74101
74102   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74103   {
74104     try {
74105       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74106     } catch (std::out_of_range& e) {
74107       {
74108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74109       };
74110     } catch (std::exception& e) {
74111       {
74112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74113       };
74114     } catch (Dali::DaliException e) {
74115       {
74116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74117       };
74118     } catch (...) {
74119       {
74120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74121       };
74122     }
74123   }
74124
74125   jresult = (void *)result;
74126   return jresult;
74127 }
74128
74129
74130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74131   unsigned int jresult ;
74132   Dali::Toolkit::ControlOrientation::Type arg1 ;
74133   bool result;
74134
74135   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74136   {
74137     try {
74138       result = (bool)Dali::Toolkit::IsVertical(arg1);
74139     } catch (std::out_of_range& e) {
74140       {
74141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (std::exception& e) {
74144       {
74145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74146       };
74147     } catch (Dali::DaliException e) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74150       };
74151     } catch (...) {
74152       {
74153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74154       };
74155     }
74156   }
74157
74158   jresult = result;
74159   return jresult;
74160 }
74161
74162
74163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74164   unsigned int jresult ;
74165   Dali::Toolkit::ControlOrientation::Type arg1 ;
74166   bool result;
74167
74168   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74169   {
74170     try {
74171       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74172     } catch (std::out_of_range& e) {
74173       {
74174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74175       };
74176     } catch (std::exception& e) {
74177       {
74178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74179       };
74180     } catch (Dali::DaliException e) {
74181       {
74182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74183       };
74184     } catch (...) {
74185       {
74186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74187       };
74188     }
74189   }
74190
74191   jresult = result;
74192   return jresult;
74193 }
74194
74195
74196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74197   void * jresult ;
74198   unsigned int arg1 ;
74199   unsigned int arg2 ;
74200   Dali::Toolkit::ItemRange *result = 0 ;
74201
74202   arg1 = (unsigned int)jarg1;
74203   arg2 = (unsigned int)jarg2;
74204   {
74205     try {
74206       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74207     } catch (std::out_of_range& e) {
74208       {
74209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74210       };
74211     } catch (std::exception& e) {
74212       {
74213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74214       };
74215     } catch (Dali::DaliException e) {
74216       {
74217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74218       };
74219     } catch (...) {
74220       {
74221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74222       };
74223     }
74224   }
74225
74226   jresult = (void *)result;
74227   return jresult;
74228 }
74229
74230
74231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74232   void * jresult ;
74233   Dali::Toolkit::ItemRange *arg1 = 0 ;
74234   Dali::Toolkit::ItemRange *result = 0 ;
74235
74236   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74237   if (!arg1) {
74238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74239     return 0;
74240   }
74241   {
74242     try {
74243       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74244     } catch (std::out_of_range& e) {
74245       {
74246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74247       };
74248     } catch (std::exception& e) {
74249       {
74250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74251       };
74252     } catch (Dali::DaliException e) {
74253       {
74254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74255       };
74256     } catch (...) {
74257       {
74258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74259       };
74260     }
74261   }
74262
74263   jresult = (void *)result;
74264   return jresult;
74265 }
74266
74267
74268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74269   void * jresult ;
74270   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74271   Dali::Toolkit::ItemRange *arg2 = 0 ;
74272   Dali::Toolkit::ItemRange *result = 0 ;
74273
74274   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74275   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74276   if (!arg2) {
74277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74278     return 0;
74279   }
74280   {
74281     try {
74282       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74283     } catch (std::out_of_range& e) {
74284       {
74285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74286       };
74287     } catch (std::exception& e) {
74288       {
74289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74290       };
74291     } catch (Dali::DaliException e) {
74292       {
74293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74294       };
74295     } catch (...) {
74296       {
74297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74298       };
74299     }
74300   }
74301
74302   jresult = (void *)result;
74303   return jresult;
74304 }
74305
74306
74307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74308   unsigned int jresult ;
74309   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74310   unsigned int arg2 ;
74311   bool result;
74312
74313   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74314   arg2 = (unsigned int)jarg2;
74315   {
74316     try {
74317       result = (bool)(arg1)->Within(arg2);
74318     } catch (std::out_of_range& e) {
74319       {
74320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74321       };
74322     } catch (std::exception& e) {
74323       {
74324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74325       };
74326     } catch (Dali::DaliException e) {
74327       {
74328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74329       };
74330     } catch (...) {
74331       {
74332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74333       };
74334     }
74335   }
74336
74337   jresult = result;
74338   return jresult;
74339 }
74340
74341
74342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74343   void * jresult ;
74344   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74345   Dali::Toolkit::ItemRange *arg2 = 0 ;
74346   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74347
74348   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74349   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74350   if (!arg2) {
74351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74352     return 0;
74353   }
74354   {
74355     try {
74356       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74357     } catch (std::out_of_range& e) {
74358       {
74359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74360       };
74361     } catch (std::exception& e) {
74362       {
74363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74364       };
74365     } catch (Dali::DaliException e) {
74366       {
74367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74368       };
74369     } catch (...) {
74370       {
74371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74372       };
74373     }
74374   }
74375
74376   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74377   return jresult;
74378 }
74379
74380
74381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74382   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74383   unsigned int arg2 ;
74384
74385   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74386   arg2 = (unsigned int)jarg2;
74387   if (arg1) (arg1)->begin = arg2;
74388 }
74389
74390
74391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74392   unsigned int jresult ;
74393   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74394   unsigned int result;
74395
74396   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74397   result = (unsigned int) ((arg1)->begin);
74398   jresult = result;
74399   return jresult;
74400 }
74401
74402
74403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74404   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74405   unsigned int arg2 ;
74406
74407   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74408   arg2 = (unsigned int)jarg2;
74409   if (arg1) (arg1)->end = arg2;
74410 }
74411
74412
74413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74414   unsigned int jresult ;
74415   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74416   unsigned int result;
74417
74418   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74419   result = (unsigned int) ((arg1)->end);
74420   jresult = result;
74421   return jresult;
74422 }
74423
74424
74425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74426   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74427
74428   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74429   {
74430     try {
74431       delete arg1;
74432     } catch (std::out_of_range& e) {
74433       {
74434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74435       };
74436     } catch (std::exception& e) {
74437       {
74438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74439       };
74440     } catch (Dali::DaliException e) {
74441       {
74442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74443       };
74444     } catch (...) {
74445       {
74446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74447       };
74448     }
74449   }
74450
74451 }
74452
74453
74454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74455   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74456
74457   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74458   {
74459     try {
74460       delete arg1;
74461     } catch (std::out_of_range& e) {
74462       {
74463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74464       };
74465     } catch (std::exception& e) {
74466       {
74467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74468       };
74469     } catch (Dali::DaliException e) {
74470       {
74471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74472       };
74473     } catch (...) {
74474       {
74475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74476       };
74477     }
74478   }
74479
74480 }
74481
74482
74483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74484   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74485   Dali::Toolkit::ControlOrientation::Type arg2 ;
74486
74487   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74488   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74489   {
74490     try {
74491       (arg1)->SetOrientation(arg2);
74492     } catch (std::out_of_range& e) {
74493       {
74494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74495       };
74496     } catch (std::exception& e) {
74497       {
74498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74499       };
74500     } catch (Dali::DaliException e) {
74501       {
74502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74503       };
74504     } catch (...) {
74505       {
74506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74507       };
74508     }
74509   }
74510
74511 }
74512
74513
74514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74515   int jresult ;
74516   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74517   Dali::Toolkit::ControlOrientation::Type result;
74518
74519   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74520   {
74521     try {
74522       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
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 = (int)result;
74543   return jresult;
74544 }
74545
74546
74547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74548   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74549   Dali::Property::Map *arg2 = 0 ;
74550
74551   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74552   arg2 = (Dali::Property::Map *)jarg2;
74553   if (!arg2) {
74554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74555     return ;
74556   }
74557   {
74558     try {
74559       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74560     } catch (std::out_of_range& e) {
74561       {
74562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74563       };
74564     } catch (std::exception& e) {
74565       {
74566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74567       };
74568     } catch (Dali::DaliException e) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74571       };
74572     } catch (...) {
74573       {
74574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74575       };
74576     }
74577   }
74578
74579 }
74580
74581
74582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74583   void * jresult ;
74584   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74585   Dali::Property::Map result;
74586
74587   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74588   {
74589     try {
74590       result = (arg1)->GetLayoutProperties();
74591     } catch (std::out_of_range& e) {
74592       {
74593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74594       };
74595     } catch (std::exception& e) {
74596       {
74597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74598       };
74599     } catch (Dali::DaliException e) {
74600       {
74601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74602       };
74603     } catch (...) {
74604       {
74605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74606       };
74607     }
74608   }
74609
74610   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74611   return jresult;
74612 }
74613
74614
74615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74616   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74617   unsigned int arg2 ;
74618   Dali::Vector3 *arg3 = 0 ;
74619   Dali::Vector3 *arg4 = 0 ;
74620
74621   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74622   arg2 = (unsigned int)jarg2;
74623   arg3 = (Dali::Vector3 *)jarg3;
74624   if (!arg3) {
74625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74626     return ;
74627   }
74628   arg4 = (Dali::Vector3 *)jarg4;
74629   if (!arg4) {
74630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74631     return ;
74632   }
74633   {
74634     try {
74635       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74636     } catch (std::out_of_range& e) {
74637       {
74638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74639       };
74640     } catch (std::exception& e) {
74641       {
74642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74643       };
74644     } catch (Dali::DaliException e) {
74645       {
74646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74647       };
74648     } catch (...) {
74649       {
74650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74651       };
74652     }
74653   }
74654
74655 }
74656
74657
74658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74659   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74660   Dali::Vector3 *arg2 = 0 ;
74661
74662   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74663   arg2 = (Dali::Vector3 *)jarg2;
74664   if (!arg2) {
74665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74666     return ;
74667   }
74668   {
74669     try {
74670       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74671     } catch (std::out_of_range& e) {
74672       {
74673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74674       };
74675     } catch (std::exception& e) {
74676       {
74677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74678       };
74679     } catch (Dali::DaliException e) {
74680       {
74681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74682       };
74683     } catch (...) {
74684       {
74685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74686       };
74687     }
74688   }
74689
74690 }
74691
74692
74693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74694   float jresult ;
74695   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74696   unsigned int arg2 ;
74697   Dali::Vector3 arg3 ;
74698   Dali::Vector3 *argp3 ;
74699   float result;
74700
74701   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74702   arg2 = (unsigned int)jarg2;
74703   argp3 = (Dali::Vector3 *)jarg3;
74704   if (!argp3) {
74705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74706     return 0;
74707   }
74708   arg3 = *argp3;
74709   {
74710     try {
74711       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74712     } catch (std::out_of_range& e) {
74713       {
74714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74715       };
74716     } catch (std::exception& e) {
74717       {
74718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74719       };
74720     } catch (Dali::DaliException e) {
74721       {
74722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74723       };
74724     } catch (...) {
74725       {
74726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74727       };
74728     }
74729   }
74730
74731   jresult = result;
74732   return jresult;
74733 }
74734
74735
74736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74737   float jresult ;
74738   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74739   float arg2 ;
74740   float result;
74741
74742   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74743   arg2 = (float)jarg2;
74744   {
74745     try {
74746       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74747     } catch (std::out_of_range& e) {
74748       {
74749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74750       };
74751     } catch (std::exception& e) {
74752       {
74753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74754       };
74755     } catch (Dali::DaliException e) {
74756       {
74757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74758       };
74759     } catch (...) {
74760       {
74761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74762       };
74763     }
74764   }
74765
74766   jresult = result;
74767   return jresult;
74768 }
74769
74770
74771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74772   float jresult ;
74773   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74774   unsigned int arg2 ;
74775   float result;
74776
74777   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74778   arg2 = (unsigned int)jarg2;
74779   {
74780     try {
74781       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74782     } catch (std::out_of_range& e) {
74783       {
74784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74785       };
74786     } catch (std::exception& e) {
74787       {
74788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74789       };
74790     } catch (Dali::DaliException e) {
74791       {
74792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74793       };
74794     } catch (...) {
74795       {
74796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74797       };
74798     }
74799   }
74800
74801   jresult = result;
74802   return jresult;
74803 }
74804
74805
74806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74807   void * jresult ;
74808   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74809   float arg2 ;
74810   Dali::Vector3 arg3 ;
74811   Dali::Vector3 *argp3 ;
74812   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74813
74814   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74815   arg2 = (float)jarg2;
74816   argp3 = (Dali::Vector3 *)jarg3;
74817   if (!argp3) {
74818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74819     return 0;
74820   }
74821   arg3 = *argp3;
74822   {
74823     try {
74824       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74825     } catch (std::out_of_range& e) {
74826       {
74827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74828       };
74829     } catch (std::exception& e) {
74830       {
74831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74832       };
74833     } catch (Dali::DaliException e) {
74834       {
74835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74836       };
74837     } catch (...) {
74838       {
74839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74840       };
74841     }
74842   }
74843
74844   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74845   return jresult;
74846 }
74847
74848
74849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74850   float jresult ;
74851   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74852   int arg2 ;
74853   float arg3 ;
74854   Dali::Vector3 *arg4 = 0 ;
74855   float result;
74856
74857   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74858   arg2 = (int)jarg2;
74859   arg3 = (float)jarg3;
74860   arg4 = (Dali::Vector3 *)jarg4;
74861   if (!arg4) {
74862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74863     return 0;
74864   }
74865   {
74866     try {
74867       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74868     } catch (std::out_of_range& e) {
74869       {
74870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74871       };
74872     } catch (std::exception& e) {
74873       {
74874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74875       };
74876     } catch (Dali::DaliException e) {
74877       {
74878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74879       };
74880     } catch (...) {
74881       {
74882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74883       };
74884     }
74885   }
74886
74887   jresult = result;
74888   return jresult;
74889 }
74890
74891
74892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74893   unsigned int jresult ;
74894   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74895   Dali::Vector3 arg2 ;
74896   Dali::Vector3 *argp2 ;
74897   unsigned int result;
74898
74899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74900   argp2 = (Dali::Vector3 *)jarg2;
74901   if (!argp2) {
74902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74903     return 0;
74904   }
74905   arg2 = *argp2;
74906   {
74907     try {
74908       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74909     } catch (std::out_of_range& e) {
74910       {
74911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74912       };
74913     } catch (std::exception& e) {
74914       {
74915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74916       };
74917     } catch (Dali::DaliException e) {
74918       {
74919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74920       };
74921     } catch (...) {
74922       {
74923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74924       };
74925     }
74926   }
74927
74928   jresult = result;
74929   return jresult;
74930 }
74931
74932
74933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74934   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74935   unsigned int arg2 ;
74936   Dali::Vector3 *arg3 = 0 ;
74937   Dali::Vector3 *arg4 = 0 ;
74938
74939   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74940   arg2 = (unsigned int)jarg2;
74941   arg3 = (Dali::Vector3 *)jarg3;
74942   if (!arg3) {
74943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74944     return ;
74945   }
74946   arg4 = (Dali::Vector3 *)jarg4;
74947   if (!arg4) {
74948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74949     return ;
74950   }
74951   {
74952     try {
74953       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74954     } catch (std::out_of_range& e) {
74955       {
74956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74957       };
74958     } catch (std::exception& e) {
74959       {
74960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74961       };
74962     } catch (Dali::DaliException e) {
74963       {
74964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74965       };
74966     } catch (...) {
74967       {
74968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74969       };
74970     }
74971   }
74972
74973 }
74974
74975
74976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74977   void * jresult ;
74978   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74979   Dali::Degree result;
74980
74981   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74982   {
74983     try {
74984       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74985     } catch (std::out_of_range& e) {
74986       {
74987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (std::exception& e) {
74990       {
74991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74992       };
74993     } catch (Dali::DaliException e) {
74994       {
74995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74996       };
74997     } catch (...) {
74998       {
74999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75000       };
75001     }
75002   }
75003
75004   jresult = new Dali::Degree((const Dali::Degree &)result);
75005   return jresult;
75006 }
75007
75008
75009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75010   float jresult ;
75011   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75012   float result;
75013
75014   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75015   {
75016     try {
75017       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75018     } catch (std::out_of_range& e) {
75019       {
75020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75021       };
75022     } catch (std::exception& e) {
75023       {
75024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75025       };
75026     } catch (Dali::DaliException e) {
75027       {
75028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75029       };
75030     } catch (...) {
75031       {
75032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75033       };
75034     }
75035   }
75036
75037   jresult = result;
75038   return jresult;
75039 }
75040
75041
75042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75043   float jresult ;
75044   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75045   float result;
75046
75047   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75048   {
75049     try {
75050       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75051     } catch (std::out_of_range& e) {
75052       {
75053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75054       };
75055     } catch (std::exception& e) {
75056       {
75057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75058       };
75059     } catch (Dali::DaliException e) {
75060       {
75061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75062       };
75063     } catch (...) {
75064       {
75065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75066       };
75067     }
75068   }
75069
75070   jresult = result;
75071   return jresult;
75072 }
75073
75074
75075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75076   float jresult ;
75077   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75078   float result;
75079
75080   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75081   {
75082     try {
75083       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75084     } catch (std::out_of_range& e) {
75085       {
75086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75087       };
75088     } catch (std::exception& e) {
75089       {
75090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75091       };
75092     } catch (Dali::DaliException e) {
75093       {
75094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75095       };
75096     } catch (...) {
75097       {
75098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75099       };
75100     }
75101   }
75102
75103   jresult = result;
75104   return jresult;
75105 }
75106
75107
75108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75109   int jresult ;
75110   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75111   int arg2 ;
75112   int arg3 ;
75113   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75114   bool arg5 ;
75115   int result;
75116
75117   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75118   arg2 = (int)jarg2;
75119   arg3 = (int)jarg3;
75120   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75121   arg5 = jarg5 ? true : false;
75122   {
75123     try {
75124       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75125     } catch (std::out_of_range& e) {
75126       {
75127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75128       };
75129     } catch (std::exception& e) {
75130       {
75131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75132       };
75133     } catch (Dali::DaliException e) {
75134       {
75135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75136       };
75137     } catch (...) {
75138       {
75139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75140       };
75141     }
75142   }
75143
75144   jresult = result;
75145   return jresult;
75146 }
75147
75148
75149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75150   float jresult ;
75151   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75152   float result;
75153
75154   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75155   {
75156     try {
75157       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75158     } catch (std::out_of_range& e) {
75159       {
75160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75161       };
75162     } catch (std::exception& e) {
75163       {
75164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75165       };
75166     } catch (Dali::DaliException e) {
75167       {
75168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75169       };
75170     } catch (...) {
75171       {
75172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75173       };
75174     }
75175   }
75176
75177   jresult = result;
75178   return jresult;
75179 }
75180
75181
75182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75183   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75184   Dali::Actor *arg2 = 0 ;
75185   int arg3 ;
75186   Dali::Vector3 *arg4 = 0 ;
75187   Dali::Actor *arg5 = 0 ;
75188
75189   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75190   arg2 = (Dali::Actor *)jarg2;
75191   if (!arg2) {
75192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75193     return ;
75194   }
75195   arg3 = (int)jarg3;
75196   arg4 = (Dali::Vector3 *)jarg4;
75197   if (!arg4) {
75198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75199     return ;
75200   }
75201   arg5 = (Dali::Actor *)jarg5;
75202   if (!arg5) {
75203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75204     return ;
75205   }
75206   {
75207     try {
75208       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75209     } catch (std::out_of_range& e) {
75210       {
75211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75212       };
75213     } catch (std::exception& e) {
75214       {
75215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75216       };
75217     } catch (Dali::DaliException e) {
75218       {
75219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75220       };
75221     } catch (...) {
75222       {
75223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75224       };
75225     }
75226   }
75227
75228 }
75229
75230
75231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75232   void * jresult ;
75233   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75234   int arg2 ;
75235   float arg3 ;
75236   Dali::Vector3 *arg4 = 0 ;
75237   Dali::Vector3 result;
75238
75239   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75240   arg2 = (int)jarg2;
75241   arg3 = (float)jarg3;
75242   arg4 = (Dali::Vector3 *)jarg4;
75243   if (!arg4) {
75244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75245     return 0;
75246   }
75247   {
75248     try {
75249       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75250     } catch (std::out_of_range& e) {
75251       {
75252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75253       };
75254     } catch (std::exception& e) {
75255       {
75256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75257       };
75258     } catch (Dali::DaliException e) {
75259       {
75260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75261       };
75262     } catch (...) {
75263       {
75264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75265       };
75266     }
75267   }
75268
75269   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75270   return jresult;
75271 }
75272
75273
75274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75275   void * jresult ;
75276   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75277   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75278
75279   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75280   {
75281     try {
75282       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75283     } catch (std::out_of_range& e) {
75284       {
75285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75286       };
75287     } catch (std::exception& e) {
75288       {
75289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75290       };
75291     } catch (Dali::DaliException e) {
75292       {
75293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75294       };
75295     } catch (...) {
75296       {
75297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75298       };
75299     }
75300   }
75301
75302   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75303   return jresult;
75304 }
75305
75306
75307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75308   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75309
75310   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75311   {
75312     try {
75313       delete arg1;
75314     } catch (std::out_of_range& e) {
75315       {
75316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75317       };
75318     } catch (std::exception& e) {
75319       {
75320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75321       };
75322     } catch (Dali::DaliException e) {
75323       {
75324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75325       };
75326     } catch (...) {
75327       {
75328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75329       };
75330     }
75331   }
75332
75333 }
75334
75335
75336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75337   unsigned int jresult ;
75338   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75339   unsigned int result;
75340
75341   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75342   {
75343     try {
75344       result = (unsigned int)(arg1)->GetNumberOfItems();
75345     } catch (std::out_of_range& e) {
75346       {
75347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75348       };
75349     } catch (std::exception& e) {
75350       {
75351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75352       };
75353     } catch (Dali::DaliException e) {
75354       {
75355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75356       };
75357     } catch (...) {
75358       {
75359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75360       };
75361     }
75362   }
75363
75364   jresult = result;
75365   return jresult;
75366 }
75367
75368
75369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75370   void * jresult ;
75371   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75372   unsigned int arg2 ;
75373   Dali::Actor result;
75374
75375   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75376   arg2 = (unsigned int)jarg2;
75377   {
75378     try {
75379       result = (arg1)->NewItem(arg2);
75380     } catch (std::out_of_range& e) {
75381       {
75382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75383       };
75384     } catch (std::exception& e) {
75385       {
75386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75387       };
75388     } catch (Dali::DaliException e) {
75389       {
75390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75391       };
75392     } catch (...) {
75393       {
75394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75395       };
75396     }
75397   }
75398
75399   jresult = new Dali::Actor((const Dali::Actor &)result);
75400   return jresult;
75401 }
75402
75403
75404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75405   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75406   unsigned int arg2 ;
75407   Dali::Actor arg3 ;
75408   Dali::Actor *argp3 ;
75409
75410   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75411   arg2 = (unsigned int)jarg2;
75412   argp3 = (Dali::Actor *)jarg3;
75413   if (!argp3) {
75414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75415     return ;
75416   }
75417   arg3 = *argp3;
75418   {
75419     try {
75420       (arg1)->ItemReleased(arg2,arg3);
75421     } catch (std::out_of_range& e) {
75422       {
75423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75424       };
75425     } catch (std::exception& e) {
75426       {
75427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75428       };
75429     } catch (Dali::DaliException e) {
75430       {
75431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75432       };
75433     } catch (...) {
75434       {
75435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75436       };
75437     }
75438   }
75439
75440 }
75441
75442
75443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75444   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75445   unsigned int arg2 ;
75446   Dali::Actor arg3 ;
75447   Dali::Actor *argp3 ;
75448
75449   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75450   arg2 = (unsigned int)jarg2;
75451   argp3 = (Dali::Actor *)jarg3;
75452   if (!argp3) {
75453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75454     return ;
75455   }
75456   arg3 = *argp3;
75457   {
75458     try {
75459       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75460     } catch (std::out_of_range& e) {
75461       {
75462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75463       };
75464     } catch (std::exception& e) {
75465       {
75466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75467       };
75468     } catch (Dali::DaliException e) {
75469       {
75470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75471       };
75472     } catch (...) {
75473       {
75474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75475       };
75476     }
75477   }
75478
75479 }
75480
75481
75482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75483   void * jresult ;
75484   Dali::Toolkit::ItemFactory *result = 0 ;
75485
75486   {
75487     try {
75488       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75489     } catch (std::out_of_range& e) {
75490       {
75491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75492       };
75493     } catch (std::exception& e) {
75494       {
75495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75496       };
75497     } catch (Dali::DaliException e) {
75498       {
75499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75500       };
75501     } catch (...) {
75502       {
75503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75504       };
75505     }
75506   }
75507
75508   jresult = (void *)result;
75509   return jresult;
75510 }
75511
75512
75513 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) {
75514   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75515   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75516   if (director) {
75517     director->swig_connect_director(callback0, callback1, callback2);
75518   }
75519 }
75520
75521
75522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75523   int jresult ;
75524   int result;
75525
75526   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75527   jresult = (int)result;
75528   return jresult;
75529 }
75530
75531
75532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75533   int jresult ;
75534   int result;
75535
75536   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75537   jresult = (int)result;
75538   return jresult;
75539 }
75540
75541
75542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75543   int jresult ;
75544   int result;
75545
75546   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75547   jresult = (int)result;
75548   return jresult;
75549 }
75550
75551
75552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75553   int jresult ;
75554   int result;
75555
75556   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75557   jresult = (int)result;
75558   return jresult;
75559 }
75560
75561
75562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75563   int jresult ;
75564   int result;
75565
75566   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75567   jresult = (int)result;
75568   return jresult;
75569 }
75570
75571
75572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75573   int jresult ;
75574   int result;
75575
75576   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75577   jresult = (int)result;
75578   return jresult;
75579 }
75580
75581
75582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75583   int jresult ;
75584   int result;
75585
75586   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75587   jresult = (int)result;
75588   return jresult;
75589 }
75590
75591
75592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75593   int jresult ;
75594   int result;
75595
75596   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75597   jresult = (int)result;
75598   return jresult;
75599 }
75600
75601
75602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75603   int jresult ;
75604   int result;
75605
75606   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75607   jresult = (int)result;
75608   return jresult;
75609 }
75610
75611
75612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75613   int jresult ;
75614   int result;
75615
75616   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75617   jresult = (int)result;
75618   return jresult;
75619 }
75620
75621
75622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75623   int jresult ;
75624   int result;
75625
75626   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75627   jresult = (int)result;
75628   return jresult;
75629 }
75630
75631
75632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75633   void * jresult ;
75634   Dali::Toolkit::ItemView::Property *result = 0 ;
75635
75636   {
75637     try {
75638       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75639     } catch (std::out_of_range& e) {
75640       {
75641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75642       };
75643     } catch (std::exception& e) {
75644       {
75645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75646       };
75647     } catch (Dali::DaliException e) {
75648       {
75649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75650       };
75651     } catch (...) {
75652       {
75653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75654       };
75655     }
75656   }
75657
75658   jresult = (void *)result;
75659   return jresult;
75660 }
75661
75662
75663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75664   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75665
75666   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75667   {
75668     try {
75669       delete arg1;
75670     } catch (std::out_of_range& e) {
75671       {
75672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75673       };
75674     } catch (std::exception& e) {
75675       {
75676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75677       };
75678     } catch (Dali::DaliException e) {
75679       {
75680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75681       };
75682     } catch (...) {
75683       {
75684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75685       };
75686     }
75687   }
75688
75689 }
75690
75691
75692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75693   void * jresult ;
75694   Dali::Toolkit::ItemView *result = 0 ;
75695
75696   {
75697     try {
75698       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75699     } catch (std::out_of_range& e) {
75700       {
75701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75702       };
75703     } catch (std::exception& e) {
75704       {
75705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75706       };
75707     } catch (Dali::DaliException e) {
75708       {
75709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75710       };
75711     } catch (...) {
75712       {
75713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75714       };
75715     }
75716   }
75717
75718   jresult = (void *)result;
75719   return jresult;
75720 }
75721
75722
75723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75724   void * jresult ;
75725   Dali::Toolkit::ItemView *arg1 = 0 ;
75726   Dali::Toolkit::ItemView *result = 0 ;
75727
75728   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75729   if (!arg1) {
75730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75731     return 0;
75732   }
75733   {
75734     try {
75735       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75736     } catch (std::out_of_range& e) {
75737       {
75738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75739       };
75740     } catch (std::exception& e) {
75741       {
75742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75743       };
75744     } catch (Dali::DaliException e) {
75745       {
75746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75747       };
75748     } catch (...) {
75749       {
75750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75751       };
75752     }
75753   }
75754
75755   jresult = (void *)result;
75756   return jresult;
75757 }
75758
75759
75760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75761   void * jresult ;
75762   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75763   Dali::Toolkit::ItemView *arg2 = 0 ;
75764   Dali::Toolkit::ItemView *result = 0 ;
75765
75766   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75767   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75768   if (!arg2) {
75769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75770     return 0;
75771   }
75772   {
75773     try {
75774       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75775     } catch (std::out_of_range& e) {
75776       {
75777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75778       };
75779     } catch (std::exception& e) {
75780       {
75781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75782       };
75783     } catch (Dali::DaliException e) {
75784       {
75785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75786       };
75787     } catch (...) {
75788       {
75789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75790       };
75791     }
75792   }
75793
75794   jresult = (void *)result;
75795   return jresult;
75796 }
75797
75798
75799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75800   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75801
75802   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75803   {
75804     try {
75805       delete arg1;
75806     } catch (std::out_of_range& e) {
75807       {
75808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75809       };
75810     } catch (std::exception& e) {
75811       {
75812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75813       };
75814     } catch (Dali::DaliException e) {
75815       {
75816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75817       };
75818     } catch (...) {
75819       {
75820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75821       };
75822     }
75823   }
75824
75825 }
75826
75827
75828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75829   void * jresult ;
75830   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75831   Dali::Toolkit::ItemView result;
75832
75833   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75834   if (!arg1) {
75835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
75836     return 0;
75837   }
75838   {
75839     try {
75840       result = Dali::Toolkit::ItemView::New(*arg1);
75841     } catch (std::out_of_range& e) {
75842       {
75843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75844       };
75845     } catch (std::exception& e) {
75846       {
75847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75848       };
75849     } catch (Dali::DaliException e) {
75850       {
75851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75852       };
75853     } catch (...) {
75854       {
75855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75856       };
75857     }
75858   }
75859
75860   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75861   return jresult;
75862 }
75863
75864
75865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
75866   void * jresult ;
75867   Dali::BaseHandle arg1 ;
75868   Dali::BaseHandle *argp1 ;
75869   Dali::Toolkit::ItemView result;
75870
75871   argp1 = (Dali::BaseHandle *)jarg1;
75872   if (!argp1) {
75873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75874     return 0;
75875   }
75876   arg1 = *argp1;
75877   {
75878     try {
75879       result = Dali::Toolkit::ItemView::DownCast(arg1);
75880     } catch (std::out_of_range& e) {
75881       {
75882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75883       };
75884     } catch (std::exception& e) {
75885       {
75886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75887       };
75888     } catch (Dali::DaliException e) {
75889       {
75890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75891       };
75892     } catch (...) {
75893       {
75894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75895       };
75896     }
75897   }
75898
75899   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75900   return jresult;
75901 }
75902
75903
75904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75905   unsigned int jresult ;
75906   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75907   unsigned int result;
75908
75909   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75910   {
75911     try {
75912       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75913     } catch (std::out_of_range& e) {
75914       {
75915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75916       };
75917     } catch (std::exception& e) {
75918       {
75919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75920       };
75921     } catch (Dali::DaliException e) {
75922       {
75923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75924       };
75925     } catch (...) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75928       };
75929     }
75930   }
75931
75932   jresult = result;
75933   return jresult;
75934 }
75935
75936
75937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75938   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75939   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75940
75941   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75942   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75943   if (!arg2) {
75944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75945     return ;
75946   }
75947   {
75948     try {
75949       (arg1)->AddLayout(*arg2);
75950     } catch (std::out_of_range& e) {
75951       {
75952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75953       };
75954     } catch (std::exception& e) {
75955       {
75956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75957       };
75958     } catch (Dali::DaliException e) {
75959       {
75960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75961       };
75962     } catch (...) {
75963       {
75964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75965       };
75966     }
75967   }
75968
75969 }
75970
75971
75972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75973   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75974   unsigned int arg2 ;
75975
75976   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75977   arg2 = (unsigned int)jarg2;
75978   {
75979     try {
75980       (arg1)->RemoveLayout(arg2);
75981     } catch (std::out_of_range& e) {
75982       {
75983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75984       };
75985     } catch (std::exception& e) {
75986       {
75987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75988       };
75989     } catch (Dali::DaliException e) {
75990       {
75991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75992       };
75993     } catch (...) {
75994       {
75995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75996       };
75997     }
75998   }
75999
76000 }
76001
76002
76003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76004   void * jresult ;
76005   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76006   unsigned int arg2 ;
76007   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76008
76009   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76010   arg2 = (unsigned int)jarg2;
76011   {
76012     try {
76013       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76014     } catch (std::out_of_range& e) {
76015       {
76016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76017       };
76018     } catch (std::exception& e) {
76019       {
76020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76021       };
76022     } catch (Dali::DaliException e) {
76023       {
76024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76025       };
76026     } catch (...) {
76027       {
76028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76029       };
76030     }
76031   }
76032
76033   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76034   return jresult;
76035 }
76036
76037
76038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76039   void * jresult ;
76040   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76041   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76042
76043   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76044   {
76045     try {
76046       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76047     } catch (std::out_of_range& e) {
76048       {
76049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76050       };
76051     } catch (std::exception& e) {
76052       {
76053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76054       };
76055     } catch (Dali::DaliException e) {
76056       {
76057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76058       };
76059     } catch (...) {
76060       {
76061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76062       };
76063     }
76064   }
76065
76066   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76067   return jresult;
76068 }
76069
76070
76071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76072   float jresult ;
76073   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76074   Dali::Toolkit::ItemId arg2 ;
76075   float result;
76076
76077   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76078   arg2 = (Dali::Toolkit::ItemId)jarg2;
76079   {
76080     try {
76081       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76082     } catch (std::out_of_range& e) {
76083       {
76084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76085       };
76086     } catch (std::exception& e) {
76087       {
76088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76089       };
76090     } catch (Dali::DaliException e) {
76091       {
76092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76093       };
76094     } catch (...) {
76095       {
76096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76097       };
76098     }
76099   }
76100
76101   jresult = result;
76102   return jresult;
76103 }
76104
76105
76106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76107   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76108   unsigned int arg2 ;
76109   Dali::Vector3 arg3 ;
76110   float arg4 ;
76111   Dali::Vector3 *argp3 ;
76112
76113   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76114   arg2 = (unsigned int)jarg2;
76115   argp3 = (Dali::Vector3 *)jarg3;
76116   if (!argp3) {
76117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76118     return ;
76119   }
76120   arg3 = *argp3;
76121   arg4 = (float)jarg4;
76122   {
76123     try {
76124       (arg1)->ActivateLayout(arg2,arg3,arg4);
76125     } catch (std::out_of_range& e) {
76126       {
76127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76128       };
76129     } catch (std::exception& e) {
76130       {
76131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76132       };
76133     } catch (Dali::DaliException e) {
76134       {
76135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76136       };
76137     } catch (...) {
76138       {
76139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76140       };
76141     }
76142   }
76143
76144 }
76145
76146
76147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76148   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76149
76150   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76151   {
76152     try {
76153       (arg1)->DeactivateCurrentLayout();
76154     } catch (std::out_of_range& e) {
76155       {
76156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76157       };
76158     } catch (std::exception& e) {
76159       {
76160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76161       };
76162     } catch (Dali::DaliException e) {
76163       {
76164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76165       };
76166     } catch (...) {
76167       {
76168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76169       };
76170     }
76171   }
76172
76173 }
76174
76175
76176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76177   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76178   float arg2 ;
76179
76180   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76181   arg2 = (float)jarg2;
76182   {
76183     try {
76184       (arg1)->SetMinimumSwipeSpeed(arg2);
76185     } catch (std::out_of_range& e) {
76186       {
76187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76188       };
76189     } catch (std::exception& e) {
76190       {
76191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76192       };
76193     } catch (Dali::DaliException e) {
76194       {
76195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76196       };
76197     } catch (...) {
76198       {
76199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76200       };
76201     }
76202   }
76203
76204 }
76205
76206
76207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76208   float jresult ;
76209   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76210   float result;
76211
76212   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76213   {
76214     try {
76215       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76216     } catch (std::out_of_range& e) {
76217       {
76218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76219       };
76220     } catch (std::exception& e) {
76221       {
76222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76223       };
76224     } catch (Dali::DaliException e) {
76225       {
76226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76227       };
76228     } catch (...) {
76229       {
76230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76231       };
76232     }
76233   }
76234
76235   jresult = result;
76236   return jresult;
76237 }
76238
76239
76240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76241   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76242   float arg2 ;
76243
76244   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76245   arg2 = (float)jarg2;
76246   {
76247     try {
76248       (arg1)->SetMinimumSwipeDistance(arg2);
76249     } catch (std::out_of_range& e) {
76250       {
76251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76252       };
76253     } catch (std::exception& e) {
76254       {
76255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76256       };
76257     } catch (Dali::DaliException e) {
76258       {
76259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76260       };
76261     } catch (...) {
76262       {
76263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76264       };
76265     }
76266   }
76267
76268 }
76269
76270
76271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76272   float jresult ;
76273   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76274   float result;
76275
76276   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76277   {
76278     try {
76279       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76280     } catch (std::out_of_range& e) {
76281       {
76282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76283       };
76284     } catch (std::exception& e) {
76285       {
76286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76287       };
76288     } catch (Dali::DaliException e) {
76289       {
76290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76291       };
76292     } catch (...) {
76293       {
76294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76295       };
76296     }
76297   }
76298
76299   jresult = result;
76300   return jresult;
76301 }
76302
76303
76304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76305   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76306   float arg2 ;
76307
76308   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76309   arg2 = (float)jarg2;
76310   {
76311     try {
76312       (arg1)->SetWheelScrollDistanceStep(arg2);
76313     } catch (std::out_of_range& e) {
76314       {
76315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76316       };
76317     } catch (std::exception& e) {
76318       {
76319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76320       };
76321     } catch (Dali::DaliException e) {
76322       {
76323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76324       };
76325     } catch (...) {
76326       {
76327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76328       };
76329     }
76330   }
76331
76332 }
76333
76334
76335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76336   float jresult ;
76337   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76338   float result;
76339
76340   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76341   {
76342     try {
76343       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76344     } catch (std::out_of_range& e) {
76345       {
76346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76347       };
76348     } catch (std::exception& e) {
76349       {
76350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76351       };
76352     } catch (Dali::DaliException e) {
76353       {
76354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76355       };
76356     } catch (...) {
76357       {
76358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76359       };
76360     }
76361   }
76362
76363   jresult = result;
76364   return jresult;
76365 }
76366
76367
76368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76369   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76370   bool arg2 ;
76371
76372   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76373   arg2 = jarg2 ? true : false;
76374   {
76375     try {
76376       (arg1)->SetAnchoring(arg2);
76377     } catch (std::out_of_range& e) {
76378       {
76379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76380       };
76381     } catch (std::exception& e) {
76382       {
76383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76384       };
76385     } catch (Dali::DaliException e) {
76386       {
76387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76388       };
76389     } catch (...) {
76390       {
76391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76392       };
76393     }
76394   }
76395
76396 }
76397
76398 //// ========================= end of part 3 =============================
76399
76400 //// ========================== start part 4 ===============================
76401
76402
76403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76404   unsigned int jresult ;
76405   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76406   bool result;
76407
76408   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76409   {
76410     try {
76411       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76412     } catch (std::out_of_range& e) {
76413       {
76414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76415       };
76416     } catch (std::exception& e) {
76417       {
76418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76419       };
76420     } catch (Dali::DaliException e) {
76421       {
76422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76423       };
76424     } catch (...) {
76425       {
76426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76427       };
76428     }
76429   }
76430
76431   jresult = result;
76432   return jresult;
76433 }
76434
76435
76436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76437   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76438   float arg2 ;
76439
76440   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76441   arg2 = (float)jarg2;
76442   {
76443     try {
76444       (arg1)->SetAnchoringDuration(arg2);
76445     } catch (std::out_of_range& e) {
76446       {
76447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76448       };
76449     } catch (std::exception& e) {
76450       {
76451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76452       };
76453     } catch (Dali::DaliException e) {
76454       {
76455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76456       };
76457     } catch (...) {
76458       {
76459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76460       };
76461     }
76462   }
76463
76464 }
76465
76466
76467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76468   float jresult ;
76469   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76470   float result;
76471
76472   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76473   {
76474     try {
76475       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76476     } catch (std::out_of_range& e) {
76477       {
76478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76479       };
76480     } catch (std::exception& e) {
76481       {
76482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76483       };
76484     } catch (Dali::DaliException e) {
76485       {
76486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76487       };
76488     } catch (...) {
76489       {
76490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76491       };
76492     }
76493   }
76494
76495   jresult = result;
76496   return jresult;
76497 }
76498
76499
76500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76501   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76502   Dali::Toolkit::ItemId arg2 ;
76503   float arg3 ;
76504
76505   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76506   arg2 = (Dali::Toolkit::ItemId)jarg2;
76507   arg3 = (float)jarg3;
76508   {
76509     try {
76510       (arg1)->ScrollToItem(arg2,arg3);
76511     } catch (std::out_of_range& e) {
76512       {
76513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76514       };
76515     } catch (std::exception& e) {
76516       {
76517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76518       };
76519     } catch (Dali::DaliException e) {
76520       {
76521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76522       };
76523     } catch (...) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76526       };
76527     }
76528   }
76529
76530 }
76531
76532
76533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76534   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76535   float arg2 ;
76536
76537   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76538   arg2 = (float)jarg2;
76539   {
76540     try {
76541       (arg1)->SetRefreshInterval(arg2);
76542     } catch (std::out_of_range& e) {
76543       {
76544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76545       };
76546     } catch (std::exception& e) {
76547       {
76548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76549       };
76550     } catch (Dali::DaliException e) {
76551       {
76552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76553       };
76554     } catch (...) {
76555       {
76556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76557       };
76558     }
76559   }
76560
76561 }
76562
76563
76564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76565   float jresult ;
76566   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76567   float result;
76568
76569   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76570   {
76571     try {
76572       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76573     } catch (std::out_of_range& e) {
76574       {
76575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76576       };
76577     } catch (std::exception& e) {
76578       {
76579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76580       };
76581     } catch (Dali::DaliException e) {
76582       {
76583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76584       };
76585     } catch (...) {
76586       {
76587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76588       };
76589     }
76590   }
76591
76592   jresult = result;
76593   return jresult;
76594 }
76595
76596
76597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76598   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76599
76600   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76601   {
76602     try {
76603       (arg1)->Refresh();
76604     } catch (std::out_of_range& e) {
76605       {
76606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76607       };
76608     } catch (std::exception& e) {
76609       {
76610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76611       };
76612     } catch (Dali::DaliException e) {
76613       {
76614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76615       };
76616     } catch (...) {
76617       {
76618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76619       };
76620     }
76621   }
76622
76623 }
76624
76625
76626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76627   void * jresult ;
76628   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76629   Dali::Toolkit::ItemId arg2 ;
76630   Dali::Actor result;
76631
76632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76633   arg2 = (Dali::Toolkit::ItemId)jarg2;
76634   {
76635     try {
76636       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76637     } catch (std::out_of_range& e) {
76638       {
76639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76640       };
76641     } catch (std::exception& e) {
76642       {
76643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76644       };
76645     } catch (Dali::DaliException e) {
76646       {
76647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76648       };
76649     } catch (...) {
76650       {
76651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76652       };
76653     }
76654   }
76655
76656   jresult = new Dali::Actor((const Dali::Actor &)result);
76657   return jresult;
76658 }
76659
76660
76661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76662   unsigned int jresult ;
76663   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76664   Dali::Actor arg2 ;
76665   Dali::Actor *argp2 ;
76666   Dali::Toolkit::ItemId result;
76667
76668   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76669   argp2 = (Dali::Actor *)jarg2;
76670   if (!argp2) {
76671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76672     return 0;
76673   }
76674   arg2 = *argp2;
76675   {
76676     try {
76677       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76678     } catch (std::out_of_range& e) {
76679       {
76680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76681       };
76682     } catch (std::exception& e) {
76683       {
76684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76685       };
76686     } catch (Dali::DaliException e) {
76687       {
76688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76689       };
76690     } catch (...) {
76691       {
76692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76693       };
76694     }
76695   }
76696
76697   jresult = result;
76698   return jresult;
76699 }
76700
76701
76702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76703   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76704   Dali::Toolkit::Item arg2 ;
76705   float arg3 ;
76706   Dali::Toolkit::Item *argp2 ;
76707
76708   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76709   argp2 = (Dali::Toolkit::Item *)jarg2;
76710   if (!argp2) {
76711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76712     return ;
76713   }
76714   arg2 = *argp2;
76715   arg3 = (float)jarg3;
76716   {
76717     try {
76718       (arg1)->InsertItem(arg2,arg3);
76719     } catch (std::out_of_range& e) {
76720       {
76721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76722       };
76723     } catch (std::exception& e) {
76724       {
76725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76726       };
76727     } catch (Dali::DaliException e) {
76728       {
76729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76730       };
76731     } catch (...) {
76732       {
76733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76734       };
76735     }
76736   }
76737
76738 }
76739
76740
76741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76742   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76743   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76744   float arg3 ;
76745
76746   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76747   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76748   if (!arg2) {
76749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76750     return ;
76751   }
76752   arg3 = (float)jarg3;
76753   {
76754     try {
76755       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76756     } catch (std::out_of_range& e) {
76757       {
76758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76759       };
76760     } catch (std::exception& e) {
76761       {
76762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76763       };
76764     } catch (Dali::DaliException e) {
76765       {
76766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76767       };
76768     } catch (...) {
76769       {
76770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76771       };
76772     }
76773   }
76774
76775 }
76776
76777
76778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76779   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76780   Dali::Toolkit::ItemId arg2 ;
76781   float arg3 ;
76782
76783   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76784   arg2 = (Dali::Toolkit::ItemId)jarg2;
76785   arg3 = (float)jarg3;
76786   {
76787     try {
76788       (arg1)->RemoveItem(arg2,arg3);
76789     } catch (std::out_of_range& e) {
76790       {
76791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76792       };
76793     } catch (std::exception& e) {
76794       {
76795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76796       };
76797     } catch (Dali::DaliException e) {
76798       {
76799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76800       };
76801     } catch (...) {
76802       {
76803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76804       };
76805     }
76806   }
76807
76808 }
76809
76810
76811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76812   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76813   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76814   float arg3 ;
76815
76816   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76817   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76818   if (!arg2) {
76819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76820     return ;
76821   }
76822   arg3 = (float)jarg3;
76823   {
76824     try {
76825       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76826     } catch (std::out_of_range& e) {
76827       {
76828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76829       };
76830     } catch (std::exception& e) {
76831       {
76832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76833       };
76834     } catch (Dali::DaliException e) {
76835       {
76836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76837       };
76838     } catch (...) {
76839       {
76840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76841       };
76842     }
76843   }
76844
76845 }
76846
76847
76848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
76849   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76850   Dali::Toolkit::Item arg2 ;
76851   float arg3 ;
76852   Dali::Toolkit::Item *argp2 ;
76853
76854   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76855   argp2 = (Dali::Toolkit::Item *)jarg2;
76856   if (!argp2) {
76857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76858     return ;
76859   }
76860   arg2 = *argp2;
76861   arg3 = (float)jarg3;
76862   {
76863     try {
76864       (arg1)->ReplaceItem(arg2,arg3);
76865     } catch (std::out_of_range& e) {
76866       {
76867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76868       };
76869     } catch (std::exception& e) {
76870       {
76871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76872       };
76873     } catch (Dali::DaliException e) {
76874       {
76875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76876       };
76877     } catch (...) {
76878       {
76879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76880       };
76881     }
76882   }
76883
76884 }
76885
76886
76887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
76888   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76889   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76890   float arg3 ;
76891
76892   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76893   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76894   if (!arg2) {
76895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76896     return ;
76897   }
76898   arg3 = (float)jarg3;
76899   {
76900     try {
76901       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76902     } catch (std::out_of_range& e) {
76903       {
76904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76905       };
76906     } catch (std::exception& e) {
76907       {
76908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76909       };
76910     } catch (Dali::DaliException e) {
76911       {
76912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76913       };
76914     } catch (...) {
76915       {
76916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76917       };
76918     }
76919   }
76920
76921 }
76922
76923
76924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76925   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76926   Dali::Vector3 *arg2 = 0 ;
76927
76928   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76929   arg2 = (Dali::Vector3 *)jarg2;
76930   if (!arg2) {
76931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76932     return ;
76933   }
76934   {
76935     try {
76936       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76937     } catch (std::out_of_range& e) {
76938       {
76939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76940       };
76941     } catch (std::exception& e) {
76942       {
76943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76944       };
76945     } catch (Dali::DaliException e) {
76946       {
76947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76948       };
76949     } catch (...) {
76950       {
76951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76952       };
76953     }
76954   }
76955
76956 }
76957
76958
76959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76960   void * jresult ;
76961   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76962   Dali::Vector3 result;
76963
76964   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76965   {
76966     try {
76967       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76968     } catch (std::out_of_range& e) {
76969       {
76970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76971       };
76972     } catch (std::exception& e) {
76973       {
76974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76975       };
76976     } catch (Dali::DaliException e) {
76977       {
76978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76979       };
76980     } catch (...) {
76981       {
76982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76983       };
76984     }
76985   }
76986
76987   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76988   return jresult;
76989 }
76990
76991
76992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76993   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76994   Dali::Vector3 *arg2 = 0 ;
76995
76996   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76997   arg2 = (Dali::Vector3 *)jarg2;
76998   if (!arg2) {
76999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77000     return ;
77001   }
77002   {
77003     try {
77004       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77005     } catch (std::out_of_range& e) {
77006       {
77007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77008       };
77009     } catch (std::exception& e) {
77010       {
77011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77012       };
77013     } catch (Dali::DaliException e) {
77014       {
77015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77016       };
77017     } catch (...) {
77018       {
77019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77020       };
77021     }
77022   }
77023
77024 }
77025
77026
77027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77028   void * jresult ;
77029   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77030   Dali::Vector3 result;
77031
77032   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77033   {
77034     try {
77035       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77036     } catch (std::out_of_range& e) {
77037       {
77038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77039       };
77040     } catch (std::exception& e) {
77041       {
77042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77043       };
77044     } catch (Dali::DaliException e) {
77045       {
77046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77047       };
77048     } catch (...) {
77049       {
77050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77051       };
77052     }
77053   }
77054
77055   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77056   return jresult;
77057 }
77058
77059
77060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77061   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77062   Dali::Toolkit::ItemRange *arg2 = 0 ;
77063
77064   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77065   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77066   if (!arg2) {
77067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77068     return ;
77069   }
77070   {
77071     try {
77072       (arg1)->GetItemsRange(*arg2);
77073     } catch (std::out_of_range& e) {
77074       {
77075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77076       };
77077     } catch (std::exception& e) {
77078       {
77079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77080       };
77081     } catch (Dali::DaliException e) {
77082       {
77083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77084       };
77085     } catch (...) {
77086       {
77087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77088       };
77089     }
77090   }
77091
77092 }
77093
77094
77095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77096   void * jresult ;
77097   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77098   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77099
77100   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77101   {
77102     try {
77103       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77104     } catch (std::out_of_range& e) {
77105       {
77106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77107       };
77108     } catch (std::exception& e) {
77109       {
77110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77111       };
77112     } catch (Dali::DaliException e) {
77113       {
77114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77115       };
77116     } catch (...) {
77117       {
77118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77119       };
77120     }
77121   }
77122
77123   jresult = (void *)result;
77124   return jresult;
77125 }
77126
77127
77128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77129   Dali::Vector3 *arg1 = 0 ;
77130   PropertyInputContainer *arg2 = 0 ;
77131
77132   arg1 = (Dali::Vector3 *)jarg1;
77133   if (!arg1) {
77134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77135     return ;
77136   }
77137   arg2 = (PropertyInputContainer *)jarg2;
77138   if (!arg2) {
77139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77140     return ;
77141   }
77142   {
77143     try {
77144       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77145     } catch (std::out_of_range& e) {
77146       {
77147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77148       };
77149     } catch (std::exception& e) {
77150       {
77151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77152       };
77153     } catch (Dali::DaliException e) {
77154       {
77155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77156       };
77157     } catch (...) {
77158       {
77159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77160       };
77161     }
77162   }
77163
77164 }
77165
77166
77167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77168   Dali::Vector3 *arg1 = 0 ;
77169   PropertyInputContainer *arg2 = 0 ;
77170
77171   arg1 = (Dali::Vector3 *)jarg1;
77172   if (!arg1) {
77173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77174     return ;
77175   }
77176   arg2 = (PropertyInputContainer *)jarg2;
77177   if (!arg2) {
77178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77179     return ;
77180   }
77181   {
77182     try {
77183       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77184     } catch (std::out_of_range& e) {
77185       {
77186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77187       };
77188     } catch (std::exception& e) {
77189       {
77190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77191       };
77192     } catch (Dali::DaliException e) {
77193       {
77194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77195       };
77196     } catch (...) {
77197       {
77198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77199       };
77200     }
77201   }
77202
77203 }
77204
77205
77206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77207   void * jresult ;
77208   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77209
77210   {
77211     try {
77212       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77213     } catch (std::out_of_range& e) {
77214       {
77215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77216       };
77217     } catch (std::exception& e) {
77218       {
77219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77220       };
77221     } catch (Dali::DaliException e) {
77222       {
77223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77224       };
77225     } catch (...) {
77226       {
77227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77228       };
77229     }
77230   }
77231
77232   jresult = (void *)result;
77233   return jresult;
77234 }
77235
77236
77237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77238   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77239
77240   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77241   {
77242     try {
77243       delete arg1;
77244     } catch (std::out_of_range& e) {
77245       {
77246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77247       };
77248     } catch (std::exception& e) {
77249       {
77250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77251       };
77252     } catch (Dali::DaliException e) {
77253       {
77254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77255       };
77256     } catch (...) {
77257       {
77258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77259       };
77260     }
77261   }
77262
77263 }
77264
77265
77266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77267   void * jresult ;
77268   Dali::Path arg1 ;
77269   Dali::Vector3 *arg2 = 0 ;
77270   Dali::Property::Index arg3 ;
77271   Dali::Vector3 *arg4 = 0 ;
77272   unsigned int arg5 ;
77273   Dali::Path *argp1 ;
77274   Dali::Toolkit::ScrollViewPagePathEffect result;
77275
77276   argp1 = (Dali::Path *)jarg1;
77277   if (!argp1) {
77278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77279     return 0;
77280   }
77281   arg1 = *argp1;
77282   arg2 = (Dali::Vector3 *)jarg2;
77283   if (!arg2) {
77284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77285     return 0;
77286   }
77287   arg3 = (Dali::Property::Index)jarg3;
77288   arg4 = (Dali::Vector3 *)jarg4;
77289   if (!arg4) {
77290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77291     return 0;
77292   }
77293   arg5 = (unsigned int)jarg5;
77294   {
77295     try {
77296       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77297     } catch (std::out_of_range& e) {
77298       {
77299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77300       };
77301     } catch (std::exception& e) {
77302       {
77303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77304       };
77305     } catch (Dali::DaliException e) {
77306       {
77307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77308       };
77309     } catch (...) {
77310       {
77311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77312       };
77313     }
77314   }
77315
77316   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77317   return jresult;
77318 }
77319
77320
77321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77322   void * jresult ;
77323   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77324
77325   {
77326     try {
77327       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77328     } catch (std::out_of_range& e) {
77329       {
77330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77331       };
77332     } catch (std::exception& e) {
77333       {
77334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77335       };
77336     } catch (Dali::DaliException e) {
77337       {
77338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77339       };
77340     } catch (...) {
77341       {
77342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77343       };
77344     }
77345   }
77346
77347   jresult = (void *)result;
77348   return jresult;
77349 }
77350
77351
77352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77353   void * jresult ;
77354   Dali::BaseHandle arg1 ;
77355   Dali::BaseHandle *argp1 ;
77356   Dali::Toolkit::ScrollViewPagePathEffect result;
77357
77358   argp1 = (Dali::BaseHandle *)jarg1;
77359   if (!argp1) {
77360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77361     return 0;
77362   }
77363   arg1 = *argp1;
77364   {
77365     try {
77366       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77367     } catch (std::out_of_range& e) {
77368       {
77369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77370       };
77371     } catch (std::exception& e) {
77372       {
77373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77374       };
77375     } catch (Dali::DaliException e) {
77376       {
77377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77378       };
77379     } catch (...) {
77380       {
77381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77382       };
77383     }
77384   }
77385
77386   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77387   return jresult;
77388 }
77389
77390
77391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77392   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77393   Dali::Actor arg2 ;
77394   unsigned int arg3 ;
77395   Dali::Actor *argp2 ;
77396
77397   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77398   argp2 = (Dali::Actor *)jarg2;
77399   if (!argp2) {
77400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77401     return ;
77402   }
77403   arg2 = *argp2;
77404   arg3 = (unsigned int)jarg3;
77405   {
77406     try {
77407       (arg1)->ApplyToPage(arg2,arg3);
77408     } catch (std::out_of_range& e) {
77409       {
77410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77411       };
77412     } catch (std::exception& e) {
77413       {
77414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77415       };
77416     } catch (Dali::DaliException e) {
77417       {
77418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77419       };
77420     } catch (...) {
77421       {
77422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77423       };
77424     }
77425   }
77426
77427 }
77428
77429
77430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77431   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77432
77433   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77434   {
77435     try {
77436       delete arg1;
77437     } catch (std::out_of_range& e) {
77438       {
77439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77440       };
77441     } catch (std::exception& e) {
77442       {
77443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77444       };
77445     } catch (Dali::DaliException e) {
77446       {
77447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77448       };
77449     } catch (...) {
77450       {
77451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77452       };
77453     }
77454   }
77455
77456 }
77457
77458
77459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77460   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77461   Dali::Toolkit::ClampState arg2 ;
77462
77463   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77464   arg2 = (Dali::Toolkit::ClampState)jarg2;
77465   if (arg1) (arg1)->x = arg2;
77466 }
77467
77468
77469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77470   int jresult ;
77471   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77472   Dali::Toolkit::ClampState result;
77473
77474   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77475   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77476   jresult = (int)result;
77477   return jresult;
77478 }
77479
77480
77481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77482   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77483   Dali::Toolkit::ClampState arg2 ;
77484
77485   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77486   arg2 = (Dali::Toolkit::ClampState)jarg2;
77487   if (arg1) (arg1)->y = arg2;
77488 }
77489
77490
77491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77492   int jresult ;
77493   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77494   Dali::Toolkit::ClampState result;
77495
77496   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77497   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77498   jresult = (int)result;
77499   return jresult;
77500 }
77501
77502
77503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77504   void * jresult ;
77505   Dali::Toolkit::ClampState2D *result = 0 ;
77506
77507   {
77508     try {
77509       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77510     } catch (std::out_of_range& e) {
77511       {
77512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77513       };
77514     } catch (std::exception& e) {
77515       {
77516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77517       };
77518     } catch (Dali::DaliException e) {
77519       {
77520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77521       };
77522     } catch (...) {
77523       {
77524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77525       };
77526     }
77527   }
77528
77529   jresult = (void *)result;
77530   return jresult;
77531 }
77532
77533
77534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77535   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77536
77537   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77538   {
77539     try {
77540       delete arg1;
77541     } catch (std::out_of_range& e) {
77542       {
77543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77544       };
77545     } catch (std::exception& e) {
77546       {
77547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77548       };
77549     } catch (Dali::DaliException e) {
77550       {
77551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77552       };
77553     } catch (...) {
77554       {
77555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77556       };
77557     }
77558   }
77559
77560 }
77561
77562
77563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77564   void * jresult ;
77565   float arg1 ;
77566   float arg2 ;
77567   bool arg3 ;
77568   Dali::Toolkit::RulerDomain *result = 0 ;
77569
77570   arg1 = (float)jarg1;
77571   arg2 = (float)jarg2;
77572   arg3 = jarg3 ? true : false;
77573   {
77574     try {
77575       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77576     } catch (std::out_of_range& e) {
77577       {
77578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77579       };
77580     } catch (std::exception& e) {
77581       {
77582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77583       };
77584     } catch (Dali::DaliException e) {
77585       {
77586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77587       };
77588     } catch (...) {
77589       {
77590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77591       };
77592     }
77593   }
77594
77595   jresult = (void *)result;
77596   return jresult;
77597 }
77598
77599
77600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77601   void * jresult ;
77602   float arg1 ;
77603   float arg2 ;
77604   Dali::Toolkit::RulerDomain *result = 0 ;
77605
77606   arg1 = (float)jarg1;
77607   arg2 = (float)jarg2;
77608   {
77609     try {
77610       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77611     } catch (std::out_of_range& e) {
77612       {
77613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77614       };
77615     } catch (std::exception& e) {
77616       {
77617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77618       };
77619     } catch (Dali::DaliException e) {
77620       {
77621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77622       };
77623     } catch (...) {
77624       {
77625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77626       };
77627     }
77628   }
77629
77630   jresult = (void *)result;
77631   return jresult;
77632 }
77633
77634
77635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77636   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77637   float arg2 ;
77638
77639   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77640   arg2 = (float)jarg2;
77641   if (arg1) (arg1)->min = arg2;
77642 }
77643
77644
77645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77646   float jresult ;
77647   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77648   float result;
77649
77650   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77651   result = (float) ((arg1)->min);
77652   jresult = result;
77653   return jresult;
77654 }
77655
77656
77657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77658   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77659   float arg2 ;
77660
77661   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77662   arg2 = (float)jarg2;
77663   if (arg1) (arg1)->max = arg2;
77664 }
77665
77666
77667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77668   float jresult ;
77669   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77670   float result;
77671
77672   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77673   result = (float) ((arg1)->max);
77674   jresult = result;
77675   return jresult;
77676 }
77677
77678
77679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77680   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77681   bool arg2 ;
77682
77683   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77684   arg2 = jarg2 ? true : false;
77685   if (arg1) (arg1)->enabled = arg2;
77686 }
77687
77688
77689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77690   unsigned int jresult ;
77691   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77692   bool result;
77693
77694   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77695   result = (bool) ((arg1)->enabled);
77696   jresult = result;
77697   return jresult;
77698 }
77699
77700
77701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77702   float jresult ;
77703   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77704   float arg2 ;
77705   float arg3 ;
77706   float arg4 ;
77707   float result;
77708
77709   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77710   arg2 = (float)jarg2;
77711   arg3 = (float)jarg3;
77712   arg4 = (float)jarg4;
77713   {
77714     try {
77715       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77716     } catch (std::out_of_range& e) {
77717       {
77718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77719       };
77720     } catch (std::exception& e) {
77721       {
77722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77723       };
77724     } catch (Dali::DaliException e) {
77725       {
77726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77727       };
77728     } catch (...) {
77729       {
77730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77731       };
77732     }
77733   }
77734
77735   jresult = result;
77736   return jresult;
77737 }
77738
77739
77740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77741   float jresult ;
77742   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77743   float arg2 ;
77744   float arg3 ;
77745   float result;
77746
77747   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77748   arg2 = (float)jarg2;
77749   arg3 = (float)jarg3;
77750   {
77751     try {
77752       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77753     } catch (std::out_of_range& e) {
77754       {
77755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77756       };
77757     } catch (std::exception& e) {
77758       {
77759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77760       };
77761     } catch (Dali::DaliException e) {
77762       {
77763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77764       };
77765     } catch (...) {
77766       {
77767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77768       };
77769     }
77770   }
77771
77772   jresult = result;
77773   return jresult;
77774 }
77775
77776
77777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77778   float jresult ;
77779   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77780   float arg2 ;
77781   float result;
77782
77783   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77784   arg2 = (float)jarg2;
77785   {
77786     try {
77787       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77788     } catch (std::out_of_range& e) {
77789       {
77790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77791       };
77792     } catch (std::exception& e) {
77793       {
77794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77795       };
77796     } catch (Dali::DaliException e) {
77797       {
77798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77799       };
77800     } catch (...) {
77801       {
77802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77803       };
77804     }
77805   }
77806
77807   jresult = result;
77808   return jresult;
77809 }
77810
77811
77812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77813   float jresult ;
77814   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77815   float arg2 ;
77816   float arg3 ;
77817   float arg4 ;
77818   Dali::Toolkit::ClampState *arg5 = 0 ;
77819   float result;
77820
77821   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77822   arg2 = (float)jarg2;
77823   arg3 = (float)jarg3;
77824   arg4 = (float)jarg4;
77825   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77826   if (!arg5) {
77827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77828     return 0;
77829   }
77830   {
77831     try {
77832       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77833     } catch (std::out_of_range& e) {
77834       {
77835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77836       };
77837     } catch (std::exception& e) {
77838       {
77839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77840       };
77841     } catch (Dali::DaliException e) {
77842       {
77843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77844       };
77845     } catch (...) {
77846       {
77847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77848       };
77849     }
77850   }
77851
77852   jresult = result;
77853   return jresult;
77854 }
77855
77856
77857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
77858   float jresult ;
77859   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77860   float result;
77861
77862   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77863   {
77864     try {
77865       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
77866     } catch (std::out_of_range& e) {
77867       {
77868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77869       };
77870     } catch (std::exception& e) {
77871       {
77872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77873       };
77874     } catch (Dali::DaliException e) {
77875       {
77876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77877       };
77878     } catch (...) {
77879       {
77880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77881       };
77882     }
77883   }
77884
77885   jresult = result;
77886   return jresult;
77887 }
77888
77889
77890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77891   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77892
77893   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77894   {
77895     try {
77896       delete arg1;
77897     } catch (std::out_of_range& e) {
77898       {
77899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77900       };
77901     } catch (std::exception& e) {
77902       {
77903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77904       };
77905     } catch (Dali::DaliException e) {
77906       {
77907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77908       };
77909     } catch (...) {
77910       {
77911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77912       };
77913     }
77914   }
77915
77916 }
77917
77918
77919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77920   float jresult ;
77921   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77922   float arg2 ;
77923   float arg3 ;
77924   float result;
77925
77926   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77927   arg2 = (float)jarg2;
77928   arg3 = (float)jarg3;
77929   {
77930     try {
77931       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77932     } catch (std::out_of_range& e) {
77933       {
77934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77935       };
77936     } catch (std::exception& e) {
77937       {
77938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77939       };
77940     } catch (Dali::DaliException e) {
77941       {
77942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77943       };
77944     } catch (...) {
77945       {
77946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77947       };
77948     }
77949   }
77950
77951   jresult = result;
77952   return jresult;
77953 }
77954
77955
77956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77957   float jresult ;
77958   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77959   float arg2 ;
77960   float result;
77961
77962   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77963   arg2 = (float)jarg2;
77964   {
77965     try {
77966       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77967     } catch (std::out_of_range& e) {
77968       {
77969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77970       };
77971     } catch (std::exception& e) {
77972       {
77973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77974       };
77975     } catch (Dali::DaliException e) {
77976       {
77977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77978       };
77979     } catch (...) {
77980       {
77981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77982       };
77983     }
77984   }
77985
77986   jresult = result;
77987   return jresult;
77988 }
77989
77990
77991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77992   float jresult ;
77993   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77994   unsigned int arg2 ;
77995   unsigned int *arg3 = 0 ;
77996   bool arg4 ;
77997   float result;
77998
77999   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78000   arg2 = (unsigned int)jarg2;
78001   arg3 = (unsigned int *)jarg3;
78002   arg4 = jarg4 ? true : false;
78003   {
78004     try {
78005       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78006     } catch (std::out_of_range& e) {
78007       {
78008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78009       };
78010     } catch (std::exception& e) {
78011       {
78012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78013       };
78014     } catch (Dali::DaliException e) {
78015       {
78016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78017       };
78018     } catch (...) {
78019       {
78020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78021       };
78022     }
78023   }
78024
78025   jresult = result;
78026   return jresult;
78027 }
78028
78029
78030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78031   unsigned int jresult ;
78032   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78033   float arg2 ;
78034   bool arg3 ;
78035   unsigned int result;
78036
78037   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78038   arg2 = (float)jarg2;
78039   arg3 = jarg3 ? true : false;
78040   {
78041     try {
78042       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78043     } catch (std::out_of_range& e) {
78044       {
78045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78046       };
78047     } catch (std::exception& e) {
78048       {
78049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78050       };
78051     } catch (Dali::DaliException e) {
78052       {
78053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78054       };
78055     } catch (...) {
78056       {
78057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78058       };
78059     }
78060   }
78061
78062   jresult = result;
78063   return jresult;
78064 }
78065
78066
78067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78068   unsigned int jresult ;
78069   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78070   unsigned int result;
78071
78072   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78073   {
78074     try {
78075       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78076     } catch (std::out_of_range& e) {
78077       {
78078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78079       };
78080     } catch (std::exception& e) {
78081       {
78082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78083       };
78084     } catch (Dali::DaliException e) {
78085       {
78086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78087       };
78088     } catch (...) {
78089       {
78090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78091       };
78092     }
78093   }
78094
78095   jresult = result;
78096   return jresult;
78097 }
78098
78099
78100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78101   int jresult ;
78102   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78103   Dali::Toolkit::Ruler::RulerType result;
78104
78105   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78106   {
78107     try {
78108       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78109     } catch (std::out_of_range& e) {
78110       {
78111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78112       };
78113     } catch (std::exception& e) {
78114       {
78115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78116       };
78117     } catch (Dali::DaliException e) {
78118       {
78119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78120       };
78121     } catch (...) {
78122       {
78123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78124       };
78125     }
78126   }
78127
78128   jresult = (int)result;
78129   return jresult;
78130 }
78131
78132
78133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78134   unsigned int jresult ;
78135   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78136   bool result;
78137
78138   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78139   {
78140     try {
78141       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78142     } catch (std::out_of_range& e) {
78143       {
78144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78145       };
78146     } catch (std::exception& e) {
78147       {
78148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78149       };
78150     } catch (Dali::DaliException e) {
78151       {
78152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78153       };
78154     } catch (...) {
78155       {
78156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78157       };
78158     }
78159   }
78160
78161   jresult = result;
78162   return jresult;
78163 }
78164
78165
78166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78167   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78168
78169   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78170   {
78171     try {
78172       (arg1)->Enable();
78173     } catch (std::out_of_range& e) {
78174       {
78175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78176       };
78177     } catch (std::exception& e) {
78178       {
78179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78180       };
78181     } catch (Dali::DaliException e) {
78182       {
78183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78184       };
78185     } catch (...) {
78186       {
78187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78188       };
78189     }
78190   }
78191
78192 }
78193
78194
78195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78196   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78197
78198   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78199   {
78200     try {
78201       (arg1)->Disable();
78202     } catch (std::out_of_range& e) {
78203       {
78204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78205       };
78206     } catch (std::exception& e) {
78207       {
78208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78209       };
78210     } catch (Dali::DaliException e) {
78211       {
78212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78213       };
78214     } catch (...) {
78215       {
78216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78217       };
78218     }
78219   }
78220
78221 }
78222
78223
78224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78225   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78226   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78227   Dali::Toolkit::RulerDomain *argp2 ;
78228
78229   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78230   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78231   if (!argp2) {
78232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78233     return ;
78234   }
78235   arg2 = *argp2;
78236   {
78237     try {
78238       (arg1)->SetDomain(arg2);
78239     } catch (std::out_of_range& e) {
78240       {
78241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78242       };
78243     } catch (std::exception& e) {
78244       {
78245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78246       };
78247     } catch (Dali::DaliException e) {
78248       {
78249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78250       };
78251     } catch (...) {
78252       {
78253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78254       };
78255     }
78256   }
78257
78258 }
78259
78260
78261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78262   void * jresult ;
78263   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78264   Dali::Toolkit::RulerDomain *result = 0 ;
78265
78266   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78267   {
78268     try {
78269       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78270     } catch (std::out_of_range& e) {
78271       {
78272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78273       };
78274     } catch (std::exception& e) {
78275       {
78276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78277       };
78278     } catch (Dali::DaliException e) {
78279       {
78280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78281       };
78282     } catch (...) {
78283       {
78284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78285       };
78286     }
78287   }
78288
78289   jresult = (void *)result;
78290   return jresult;
78291 }
78292
78293
78294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78295   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78296
78297   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78298   {
78299     try {
78300       (arg1)->DisableDomain();
78301     } catch (std::out_of_range& e) {
78302       {
78303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78304       };
78305     } catch (std::exception& e) {
78306       {
78307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78308       };
78309     } catch (Dali::DaliException e) {
78310       {
78311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78312       };
78313     } catch (...) {
78314       {
78315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78316       };
78317     }
78318   }
78319
78320 }
78321
78322
78323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78324   float jresult ;
78325   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78326   float arg2 ;
78327   float arg3 ;
78328   float arg4 ;
78329   float result;
78330
78331   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78332   arg2 = (float)jarg2;
78333   arg3 = (float)jarg3;
78334   arg4 = (float)jarg4;
78335   {
78336     try {
78337       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78338     } catch (std::out_of_range& e) {
78339       {
78340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78341       };
78342     } catch (std::exception& e) {
78343       {
78344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78345       };
78346     } catch (Dali::DaliException e) {
78347       {
78348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78349       };
78350     } catch (...) {
78351       {
78352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78353       };
78354     }
78355   }
78356
78357   jresult = result;
78358   return jresult;
78359 }
78360
78361
78362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78363   float jresult ;
78364   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78365   float arg2 ;
78366   float arg3 ;
78367   float result;
78368
78369   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78370   arg2 = (float)jarg2;
78371   arg3 = (float)jarg3;
78372   {
78373     try {
78374       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78375     } catch (std::out_of_range& e) {
78376       {
78377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78378       };
78379     } catch (std::exception& e) {
78380       {
78381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78382       };
78383     } catch (Dali::DaliException e) {
78384       {
78385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78386       };
78387     } catch (...) {
78388       {
78389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78390       };
78391     }
78392   }
78393
78394   jresult = result;
78395   return jresult;
78396 }
78397
78398
78399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78400   float jresult ;
78401   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78402   float arg2 ;
78403   float result;
78404
78405   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78406   arg2 = (float)jarg2;
78407   {
78408     try {
78409       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78410     } catch (std::out_of_range& e) {
78411       {
78412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78413       };
78414     } catch (std::exception& e) {
78415       {
78416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78417       };
78418     } catch (Dali::DaliException e) {
78419       {
78420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78421       };
78422     } catch (...) {
78423       {
78424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78425       };
78426     }
78427   }
78428
78429   jresult = result;
78430   return jresult;
78431 }
78432
78433
78434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78435   float jresult ;
78436   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78437   float arg2 ;
78438   float arg3 ;
78439   float arg4 ;
78440   Dali::Toolkit::ClampState *arg5 = 0 ;
78441   float result;
78442
78443   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78444   arg2 = (float)jarg2;
78445   arg3 = (float)jarg3;
78446   arg4 = (float)jarg4;
78447   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78448   if (!arg5) {
78449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78450     return 0;
78451   }
78452   {
78453     try {
78454       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78455     } catch (std::out_of_range& e) {
78456       {
78457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78458       };
78459     } catch (std::exception& e) {
78460       {
78461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78462       };
78463     } catch (Dali::DaliException e) {
78464       {
78465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78466       };
78467     } catch (...) {
78468       {
78469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78470       };
78471     }
78472   }
78473
78474   jresult = result;
78475   return jresult;
78476 }
78477
78478
78479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78480   float jresult ;
78481   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78482   float arg2 ;
78483   float arg3 ;
78484   float arg4 ;
78485   float arg5 ;
78486   float result;
78487
78488   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78489   arg2 = (float)jarg2;
78490   arg3 = (float)jarg3;
78491   arg4 = (float)jarg4;
78492   arg5 = (float)jarg5;
78493   {
78494     try {
78495       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78496     } catch (std::out_of_range& e) {
78497       {
78498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78499       };
78500     } catch (std::exception& e) {
78501       {
78502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78503       };
78504     } catch (Dali::DaliException e) {
78505       {
78506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78507       };
78508     } catch (...) {
78509       {
78510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78511       };
78512     }
78513   }
78514
78515   jresult = result;
78516   return jresult;
78517 }
78518
78519
78520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78521   float jresult ;
78522   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78523   float arg2 ;
78524   float arg3 ;
78525   float arg4 ;
78526   float result;
78527
78528   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78529   arg2 = (float)jarg2;
78530   arg3 = (float)jarg3;
78531   arg4 = (float)jarg4;
78532   {
78533     try {
78534       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78535     } catch (std::out_of_range& e) {
78536       {
78537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78538       };
78539     } catch (std::exception& e) {
78540       {
78541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78542       };
78543     } catch (Dali::DaliException e) {
78544       {
78545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78546       };
78547     } catch (...) {
78548       {
78549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78550       };
78551     }
78552   }
78553
78554   jresult = result;
78555   return jresult;
78556 }
78557
78558
78559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78560   float jresult ;
78561   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78562   float arg2 ;
78563   float arg3 ;
78564   float result;
78565
78566   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78567   arg2 = (float)jarg2;
78568   arg3 = (float)jarg3;
78569   {
78570     try {
78571       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78572     } catch (std::out_of_range& e) {
78573       {
78574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78575       };
78576     } catch (std::exception& e) {
78577       {
78578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78579       };
78580     } catch (Dali::DaliException e) {
78581       {
78582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78583       };
78584     } catch (...) {
78585       {
78586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78587       };
78588     }
78589   }
78590
78591   jresult = result;
78592   return jresult;
78593 }
78594
78595
78596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78597   float jresult ;
78598   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78599   float arg2 ;
78600   float result;
78601
78602   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78603   arg2 = (float)jarg2;
78604   {
78605     try {
78606       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78607     } catch (std::out_of_range& e) {
78608       {
78609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78610       };
78611     } catch (std::exception& e) {
78612       {
78613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78614       };
78615     } catch (Dali::DaliException e) {
78616       {
78617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78618       };
78619     } catch (...) {
78620       {
78621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78622       };
78623     }
78624   }
78625
78626   jresult = result;
78627   return jresult;
78628 }
78629
78630
78631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78632   float jresult ;
78633   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78634   float arg2 ;
78635   float arg3 ;
78636   float arg4 ;
78637   float arg5 ;
78638   Dali::Toolkit::ClampState *arg6 = 0 ;
78639   float result;
78640
78641   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78642   arg2 = (float)jarg2;
78643   arg3 = (float)jarg3;
78644   arg4 = (float)jarg4;
78645   arg5 = (float)jarg5;
78646   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78647   if (!arg6) {
78648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78649     return 0;
78650   }
78651   {
78652     try {
78653       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78654     } catch (std::out_of_range& e) {
78655       {
78656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78657       };
78658     } catch (std::exception& e) {
78659       {
78660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78661       };
78662     } catch (Dali::DaliException e) {
78663       {
78664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78665       };
78666     } catch (...) {
78667       {
78668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78669       };
78670     }
78671   }
78672
78673   jresult = result;
78674   return jresult;
78675 }
78676
78677
78678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78679   void * jresult ;
78680   Dali::Toolkit::DefaultRuler *result = 0 ;
78681
78682   {
78683     try {
78684       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
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 = (void *)result;
78705   return jresult;
78706 }
78707
78708
78709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78710   float jresult ;
78711   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78712   float arg2 ;
78713   float arg3 ;
78714   float result;
78715
78716   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78717   arg2 = (float)jarg2;
78718   arg3 = (float)jarg3;
78719   {
78720     try {
78721       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(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 float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78747   float jresult ;
78748   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78749   unsigned int arg2 ;
78750   unsigned int *arg3 = 0 ;
78751   bool arg4 ;
78752   float result;
78753
78754   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78755   arg2 = (unsigned int)jarg2;
78756   arg3 = (unsigned int *)jarg3;
78757   arg4 = jarg4 ? true : false;
78758   {
78759     try {
78760       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78761     } catch (std::out_of_range& e) {
78762       {
78763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78764       };
78765     } catch (std::exception& e) {
78766       {
78767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78768       };
78769     } catch (Dali::DaliException e) {
78770       {
78771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78772       };
78773     } catch (...) {
78774       {
78775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78776       };
78777     }
78778   }
78779
78780   jresult = result;
78781   return jresult;
78782 }
78783
78784
78785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78786   unsigned int jresult ;
78787   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78788   float arg2 ;
78789   bool arg3 ;
78790   unsigned int result;
78791
78792   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78793   arg2 = (float)jarg2;
78794   arg3 = jarg3 ? true : false;
78795   {
78796     try {
78797       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78798     } catch (std::out_of_range& e) {
78799       {
78800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78801       };
78802     } catch (std::exception& e) {
78803       {
78804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78805       };
78806     } catch (Dali::DaliException e) {
78807       {
78808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78809       };
78810     } catch (...) {
78811       {
78812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78813       };
78814     }
78815   }
78816
78817   jresult = result;
78818   return jresult;
78819 }
78820
78821
78822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78823   unsigned int jresult ;
78824   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78825   unsigned int result;
78826
78827   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78828   {
78829     try {
78830       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78831     } catch (std::out_of_range& e) {
78832       {
78833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78834       };
78835     } catch (std::exception& e) {
78836       {
78837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78838       };
78839     } catch (Dali::DaliException e) {
78840       {
78841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78842       };
78843     } catch (...) {
78844       {
78845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78846       };
78847     }
78848   }
78849
78850   jresult = result;
78851   return jresult;
78852 }
78853
78854
78855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
78856   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78857
78858   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78859   {
78860     try {
78861       delete arg1;
78862     } catch (std::out_of_range& e) {
78863       {
78864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78865       };
78866     } catch (std::exception& e) {
78867       {
78868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78869       };
78870     } catch (Dali::DaliException e) {
78871       {
78872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78873       };
78874     } catch (...) {
78875       {
78876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78877       };
78878     }
78879   }
78880
78881 }
78882
78883
78884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
78885   void * jresult ;
78886   float arg1 ;
78887   Dali::Toolkit::FixedRuler *result = 0 ;
78888
78889   arg1 = (float)jarg1;
78890   {
78891     try {
78892       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78893     } catch (std::out_of_range& e) {
78894       {
78895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78896       };
78897     } catch (std::exception& e) {
78898       {
78899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78900       };
78901     } catch (Dali::DaliException e) {
78902       {
78903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78904       };
78905     } catch (...) {
78906       {
78907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78908       };
78909     }
78910   }
78911
78912   jresult = (void *)result;
78913   return jresult;
78914 }
78915
78916
78917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78918   void * jresult ;
78919   Dali::Toolkit::FixedRuler *result = 0 ;
78920
78921   {
78922     try {
78923       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78924     } catch (std::out_of_range& e) {
78925       {
78926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78927       };
78928     } catch (std::exception& e) {
78929       {
78930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78931       };
78932     } catch (Dali::DaliException e) {
78933       {
78934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78935       };
78936     } catch (...) {
78937       {
78938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78939       };
78940     }
78941   }
78942
78943   jresult = (void *)result;
78944   return jresult;
78945 }
78946
78947
78948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78949   float jresult ;
78950   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78951   float arg2 ;
78952   float arg3 ;
78953   float result;
78954
78955   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78956   arg2 = (float)jarg2;
78957   arg3 = (float)jarg3;
78958   {
78959     try {
78960       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78961     } catch (std::out_of_range& e) {
78962       {
78963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78964       };
78965     } catch (std::exception& e) {
78966       {
78967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78968       };
78969     } catch (Dali::DaliException e) {
78970       {
78971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78972       };
78973     } catch (...) {
78974       {
78975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78976       };
78977     }
78978   }
78979
78980   jresult = result;
78981   return jresult;
78982 }
78983
78984
78985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78986   float jresult ;
78987   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78988   unsigned int arg2 ;
78989   unsigned int *arg3 = 0 ;
78990   bool arg4 ;
78991   float result;
78992
78993   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78994   arg2 = (unsigned int)jarg2;
78995   arg3 = (unsigned int *)jarg3;
78996   arg4 = jarg4 ? true : false;
78997   {
78998     try {
78999       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79000     } catch (std::out_of_range& e) {
79001       {
79002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79003       };
79004     } catch (std::exception& e) {
79005       {
79006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79007       };
79008     } catch (Dali::DaliException e) {
79009       {
79010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79011       };
79012     } catch (...) {
79013       {
79014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79015       };
79016     }
79017   }
79018
79019   jresult = result;
79020   return jresult;
79021 }
79022
79023
79024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79025   unsigned int jresult ;
79026   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79027   float arg2 ;
79028   bool arg3 ;
79029   unsigned int result;
79030
79031   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79032   arg2 = (float)jarg2;
79033   arg3 = jarg3 ? true : false;
79034   {
79035     try {
79036       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79037     } catch (std::out_of_range& e) {
79038       {
79039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79040       };
79041     } catch (std::exception& e) {
79042       {
79043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79044       };
79045     } catch (Dali::DaliException e) {
79046       {
79047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79048       };
79049     } catch (...) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79052       };
79053     }
79054   }
79055
79056   jresult = result;
79057   return jresult;
79058 }
79059
79060
79061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79062   unsigned int jresult ;
79063   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79064   unsigned int result;
79065
79066   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79067   {
79068     try {
79069       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79070     } catch (std::out_of_range& e) {
79071       {
79072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79073       };
79074     } catch (std::exception& e) {
79075       {
79076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79077       };
79078     } catch (Dali::DaliException e) {
79079       {
79080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79081       };
79082     } catch (...) {
79083       {
79084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79085       };
79086     }
79087   }
79088
79089   jresult = result;
79090   return jresult;
79091 }
79092
79093
79094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79095   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79096
79097   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79098   {
79099     try {
79100       delete arg1;
79101     } catch (std::out_of_range& e) {
79102       {
79103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79104       };
79105     } catch (std::exception& e) {
79106       {
79107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79108       };
79109     } catch (Dali::DaliException e) {
79110       {
79111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79112       };
79113     } catch (...) {
79114       {
79115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79116       };
79117     }
79118   }
79119
79120 }
79121
79122
79123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79124   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79125   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79126
79127   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79128   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79129   if (arg1) (arg1)->scale = *arg2;
79130 }
79131
79132
79133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79134   void * jresult ;
79135   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79136   Dali::Toolkit::ClampState2D *result = 0 ;
79137
79138   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79139   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79140   jresult = (void *)result;
79141   return jresult;
79142 }
79143
79144
79145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79146   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79147   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79148
79149   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79150   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79151   if (arg1) (arg1)->position = *arg2;
79152 }
79153
79154
79155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79156   void * jresult ;
79157   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79158   Dali::Toolkit::ClampState2D *result = 0 ;
79159
79160   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79161   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79162   jresult = (void *)result;
79163   return jresult;
79164 }
79165
79166
79167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79168   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79169   Dali::Toolkit::ClampState arg2 ;
79170
79171   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79172   arg2 = (Dali::Toolkit::ClampState)jarg2;
79173   if (arg1) (arg1)->rotation = arg2;
79174 }
79175
79176
79177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79178   int jresult ;
79179   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79180   Dali::Toolkit::ClampState result;
79181
79182   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79183   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79184   jresult = (int)result;
79185   return jresult;
79186 }
79187
79188
79189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79190   void * jresult ;
79191   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79192
79193   {
79194     try {
79195       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79196     } catch (std::out_of_range& e) {
79197       {
79198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79199       };
79200     } catch (std::exception& e) {
79201       {
79202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79203       };
79204     } catch (Dali::DaliException e) {
79205       {
79206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79207       };
79208     } catch (...) {
79209       {
79210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79211       };
79212     }
79213   }
79214
79215   jresult = (void *)result;
79216   return jresult;
79217 }
79218
79219
79220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79221   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79222
79223   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79224   {
79225     try {
79226       delete arg1;
79227     } catch (std::out_of_range& e) {
79228       {
79229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79230       };
79231     } catch (std::exception& e) {
79232       {
79233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79234       };
79235     } catch (Dali::DaliException e) {
79236       {
79237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79238       };
79239     } catch (...) {
79240       {
79241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79242       };
79243     }
79244   }
79245
79246 }
79247
79248
79249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79250   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79251   Dali::Toolkit::SnapType arg2 ;
79252
79253   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79254   arg2 = (Dali::Toolkit::SnapType)jarg2;
79255   if (arg1) (arg1)->type = arg2;
79256 }
79257
79258
79259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79260   int jresult ;
79261   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79262   Dali::Toolkit::SnapType result;
79263
79264   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79265   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79266   jresult = (int)result;
79267   return jresult;
79268 }
79269
79270
79271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79272   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79273   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79274
79275   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79276   arg2 = (Dali::Vector2 *)jarg2;
79277   if (arg1) (arg1)->position = *arg2;
79278 }
79279
79280
79281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79282   void * jresult ;
79283   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79284   Dali::Vector2 *result = 0 ;
79285
79286   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79287   result = (Dali::Vector2 *)& ((arg1)->position);
79288   jresult = (void *)result;
79289   return jresult;
79290 }
79291
79292
79293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79294   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79295   float arg2 ;
79296
79297   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79298   arg2 = (float)jarg2;
79299   if (arg1) (arg1)->duration = arg2;
79300 }
79301
79302
79303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79304   float jresult ;
79305   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79306   float result;
79307
79308   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79309   result = (float) ((arg1)->duration);
79310   jresult = result;
79311   return jresult;
79312 }
79313
79314
79315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79316   void * jresult ;
79317   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79318
79319   {
79320     try {
79321       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79322     } catch (std::out_of_range& e) {
79323       {
79324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79325       };
79326     } catch (std::exception& e) {
79327       {
79328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79329       };
79330     } catch (Dali::DaliException e) {
79331       {
79332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79333       };
79334     } catch (...) {
79335       {
79336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79337       };
79338     }
79339   }
79340
79341   jresult = (void *)result;
79342   return jresult;
79343 }
79344
79345
79346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79347   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79348
79349   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79350   {
79351     try {
79352       delete arg1;
79353     } catch (std::out_of_range& e) {
79354       {
79355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79356       };
79357     } catch (std::exception& e) {
79358       {
79359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79360       };
79361     } catch (Dali::DaliException e) {
79362       {
79363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79364       };
79365     } catch (...) {
79366       {
79367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79368       };
79369     }
79370   }
79371
79372 }
79373
79374
79375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79376   int jresult ;
79377   int result;
79378
79379   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79380   jresult = (int)result;
79381   return jresult;
79382 }
79383
79384
79385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79386   int jresult ;
79387   int result;
79388
79389   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79390   jresult = (int)result;
79391   return jresult;
79392 }
79393
79394
79395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79396   int jresult ;
79397   int result;
79398
79399   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79400   jresult = (int)result;
79401   return jresult;
79402 }
79403
79404
79405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79406   int jresult ;
79407   int result;
79408
79409   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79410   jresult = (int)result;
79411   return jresult;
79412 }
79413
79414
79415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79416   int jresult ;
79417   int result;
79418
79419   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79420   jresult = (int)result;
79421   return jresult;
79422 }
79423
79424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79425   int jresult ;
79426   int result;
79427
79428   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79429   jresult = (int)result;
79430   return jresult;
79431 }
79432
79433
79434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79435   int jresult ;
79436   int result;
79437
79438   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79439   jresult = (int)result;
79440   return jresult;
79441 }
79442
79443
79444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79445   int jresult ;
79446   int result;
79447
79448   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79449   jresult = (int)result;
79450   return jresult;
79451 }
79452
79453
79454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79455   int jresult ;
79456   int result;
79457
79458   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79459   jresult = (int)result;
79460   return jresult;
79461 }
79462
79463
79464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79465   int jresult ;
79466   int result;
79467
79468   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79469   jresult = (int)result;
79470   return jresult;
79471 }
79472
79473
79474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79475   int jresult ;
79476   int result;
79477
79478   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79479   jresult = (int)result;
79480   return jresult;
79481 }
79482
79483
79484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79485   int jresult ;
79486   int result;
79487
79488   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79489   jresult = (int)result;
79490   return jresult;
79491 }
79492
79493
79494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79495   int jresult ;
79496   int result;
79497
79498   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79499   jresult = (int)result;
79500   return jresult;
79501 }
79502
79503
79504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79505   int jresult ;
79506   int result;
79507
79508   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79509   jresult = (int)result;
79510   return jresult;
79511 }
79512
79513
79514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79515   int jresult ;
79516   int result;
79517
79518   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79519   jresult = (int)result;
79520   return jresult;
79521 }
79522
79523
79524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79525   int jresult ;
79526   int result;
79527
79528   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79529   jresult = (int)result;
79530   return jresult;
79531 }
79532
79533
79534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79535   int jresult ;
79536   int result;
79537
79538   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79539   jresult = (int)result;
79540   return jresult;
79541 }
79542
79543
79544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79545   int jresult ;
79546   int result;
79547
79548   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79549   jresult = (int)result;
79550   return jresult;
79551 }
79552
79553
79554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79555   int jresult ;
79556   int result;
79557
79558   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79559   jresult = (int)result;
79560   return jresult;
79561 }
79562
79563
79564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79565   int jresult ;
79566   int result;
79567
79568   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79569   jresult = (int)result;
79570   return jresult;
79571 }
79572
79573
79574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79575   int jresult ;
79576   int result;
79577
79578   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79579   jresult = (int)result;
79580   return jresult;
79581 }
79582
79583
79584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79585   int jresult ;
79586   int result;
79587
79588   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79589   jresult = (int)result;
79590   return jresult;
79591 }
79592
79593
79594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79595   int jresult ;
79596   int result;
79597
79598   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79599   jresult = (int)result;
79600   return jresult;
79601 }
79602
79603
79604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79605   int jresult ;
79606   int result;
79607
79608   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79609   jresult = (int)result;
79610   return jresult;
79611 }
79612
79613
79614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79615   int jresult ;
79616   int result;
79617
79618   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79619   jresult = (int)result;
79620   return jresult;
79621 }
79622
79623
79624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79625   int jresult ;
79626   int result;
79627
79628   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79629   jresult = (int)result;
79630   return jresult;
79631 }
79632
79633
79634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79635   void * jresult ;
79636   Dali::Toolkit::ScrollView::Property *result = 0 ;
79637
79638   {
79639     try {
79640       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79641     } catch (std::out_of_range& e) {
79642       {
79643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79644       };
79645     } catch (std::exception& e) {
79646       {
79647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79648       };
79649     } catch (Dali::DaliException e) {
79650       {
79651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79652       };
79653     } catch (...) {
79654       {
79655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79656       };
79657     }
79658   }
79659
79660   jresult = (void *)result;
79661   return jresult;
79662 }
79663
79664
79665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79666   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79667
79668   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79669   {
79670     try {
79671       delete arg1;
79672     } catch (std::out_of_range& e) {
79673       {
79674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79675       };
79676     } catch (std::exception& e) {
79677       {
79678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79679       };
79680     } catch (Dali::DaliException e) {
79681       {
79682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79683       };
79684     } catch (...) {
79685       {
79686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79687       };
79688     }
79689   }
79690
79691 }
79692
79693
79694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79695   void * jresult ;
79696   Dali::Toolkit::ScrollView *result = 0 ;
79697
79698   {
79699     try {
79700       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79701     } catch (std::out_of_range& e) {
79702       {
79703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79704       };
79705     } catch (std::exception& e) {
79706       {
79707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79708       };
79709     } catch (Dali::DaliException e) {
79710       {
79711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79712       };
79713     } catch (...) {
79714       {
79715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79716       };
79717     }
79718   }
79719
79720   jresult = (void *)result;
79721   return jresult;
79722 }
79723
79724
79725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79726   void * jresult ;
79727   Dali::Toolkit::ScrollView *arg1 = 0 ;
79728   Dali::Toolkit::ScrollView *result = 0 ;
79729
79730   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79731   if (!arg1) {
79732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79733     return 0;
79734   }
79735   {
79736     try {
79737       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79738     } catch (std::out_of_range& e) {
79739       {
79740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79741       };
79742     } catch (std::exception& e) {
79743       {
79744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79745       };
79746     } catch (Dali::DaliException e) {
79747       {
79748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79749       };
79750     } catch (...) {
79751       {
79752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79753       };
79754     }
79755   }
79756
79757   jresult = (void *)result;
79758   return jresult;
79759 }
79760
79761
79762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79763   void * jresult ;
79764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79765   Dali::Toolkit::ScrollView *arg2 = 0 ;
79766   Dali::Toolkit::ScrollView *result = 0 ;
79767
79768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79769   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79770   if (!arg2) {
79771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79772     return 0;
79773   }
79774   {
79775     try {
79776       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79777     } catch (std::out_of_range& e) {
79778       {
79779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79780       };
79781     } catch (std::exception& e) {
79782       {
79783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79784       };
79785     } catch (Dali::DaliException e) {
79786       {
79787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79788       };
79789     } catch (...) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79792       };
79793     }
79794   }
79795
79796   jresult = (void *)result;
79797   return jresult;
79798 }
79799
79800
79801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79802   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79803
79804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79805   {
79806     try {
79807       delete arg1;
79808     } catch (std::out_of_range& e) {
79809       {
79810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79811       };
79812     } catch (std::exception& e) {
79813       {
79814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79815       };
79816     } catch (Dali::DaliException e) {
79817       {
79818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79819       };
79820     } catch (...) {
79821       {
79822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79823       };
79824     }
79825   }
79826
79827 }
79828
79829
79830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79831   void * jresult ;
79832   Dali::Toolkit::ScrollView result;
79833
79834   {
79835     try {
79836       result = Dali::Toolkit::ScrollView::New();
79837     } catch (std::out_of_range& e) {
79838       {
79839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79840       };
79841     } catch (std::exception& e) {
79842       {
79843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79844       };
79845     } catch (Dali::DaliException e) {
79846       {
79847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79848       };
79849     } catch (...) {
79850       {
79851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79852       };
79853     }
79854   }
79855
79856   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79857   return jresult;
79858 }
79859
79860
79861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
79862   void * jresult ;
79863   Dali::BaseHandle arg1 ;
79864   Dali::BaseHandle *argp1 ;
79865   Dali::Toolkit::ScrollView result;
79866
79867   argp1 = (Dali::BaseHandle *)jarg1;
79868   if (!argp1) {
79869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79870     return 0;
79871   }
79872   arg1 = *argp1;
79873   {
79874     try {
79875       result = Dali::Toolkit::ScrollView::DownCast(arg1);
79876     } catch (std::out_of_range& e) {
79877       {
79878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79879       };
79880     } catch (std::exception& e) {
79881       {
79882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79883       };
79884     } catch (Dali::DaliException e) {
79885       {
79886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79887       };
79888     } catch (...) {
79889       {
79890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79891       };
79892     }
79893   }
79894
79895   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79896   return jresult;
79897 }
79898
79899
79900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79901   void * jresult ;
79902   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79903   Dali::AlphaFunction result;
79904
79905   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79906   {
79907     try {
79908       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79909     } catch (std::out_of_range& e) {
79910       {
79911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79912       };
79913     } catch (std::exception& e) {
79914       {
79915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79916       };
79917     } catch (Dali::DaliException e) {
79918       {
79919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79920       };
79921     } catch (...) {
79922       {
79923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79924       };
79925     }
79926   }
79927
79928   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79929   return jresult;
79930 }
79931
79932
79933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79934   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79935   Dali::AlphaFunction arg2 ;
79936   Dali::AlphaFunction *argp2 ;
79937
79938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79939   argp2 = (Dali::AlphaFunction *)jarg2;
79940   if (!argp2) {
79941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79942     return ;
79943   }
79944   arg2 = *argp2;
79945   {
79946     try {
79947       (arg1)->SetScrollSnapAlphaFunction(arg2);
79948     } catch (std::out_of_range& e) {
79949       {
79950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79951       };
79952     } catch (std::exception& e) {
79953       {
79954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79955       };
79956     } catch (Dali::DaliException e) {
79957       {
79958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79959       };
79960     } catch (...) {
79961       {
79962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79963       };
79964     }
79965   }
79966
79967 }
79968
79969
79970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79971   void * jresult ;
79972   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79973   Dali::AlphaFunction result;
79974
79975   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79976   {
79977     try {
79978       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79979     } catch (std::out_of_range& e) {
79980       {
79981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79982       };
79983     } catch (std::exception& e) {
79984       {
79985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79986       };
79987     } catch (Dali::DaliException e) {
79988       {
79989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79990       };
79991     } catch (...) {
79992       {
79993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79994       };
79995     }
79996   }
79997
79998   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79999   return jresult;
80000 }
80001
80002
80003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80004   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80005   Dali::AlphaFunction arg2 ;
80006   Dali::AlphaFunction *argp2 ;
80007
80008   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80009   argp2 = (Dali::AlphaFunction *)jarg2;
80010   if (!argp2) {
80011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80012     return ;
80013   }
80014   arg2 = *argp2;
80015   {
80016     try {
80017       (arg1)->SetScrollFlickAlphaFunction(arg2);
80018     } catch (std::out_of_range& e) {
80019       {
80020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80021       };
80022     } catch (std::exception& e) {
80023       {
80024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80025       };
80026     } catch (Dali::DaliException e) {
80027       {
80028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80029       };
80030     } catch (...) {
80031       {
80032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80033       };
80034     }
80035   }
80036
80037 }
80038
80039
80040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80041   float jresult ;
80042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80043   float result;
80044
80045   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80046   {
80047     try {
80048       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80049     } catch (std::out_of_range& e) {
80050       {
80051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80052       };
80053     } catch (std::exception& e) {
80054       {
80055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80056       };
80057     } catch (Dali::DaliException e) {
80058       {
80059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80060       };
80061     } catch (...) {
80062       {
80063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80064       };
80065     }
80066   }
80067
80068   jresult = result;
80069   return jresult;
80070 }
80071
80072
80073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80075   float arg2 ;
80076
80077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80078   arg2 = (float)jarg2;
80079   {
80080     try {
80081       (arg1)->SetScrollSnapDuration(arg2);
80082     } catch (std::out_of_range& e) {
80083       {
80084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80085       };
80086     } catch (std::exception& e) {
80087       {
80088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80089       };
80090     } catch (Dali::DaliException e) {
80091       {
80092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80093       };
80094     } catch (...) {
80095       {
80096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80097       };
80098     }
80099   }
80100
80101 }
80102
80103
80104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80105   float jresult ;
80106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80107   float result;
80108
80109   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80110   {
80111     try {
80112       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80113     } catch (std::out_of_range& e) {
80114       {
80115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80116       };
80117     } catch (std::exception& e) {
80118       {
80119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80120       };
80121     } catch (Dali::DaliException e) {
80122       {
80123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80124       };
80125     } catch (...) {
80126       {
80127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80128       };
80129     }
80130   }
80131
80132   jresult = result;
80133   return jresult;
80134 }
80135
80136
80137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80138   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80139   float arg2 ;
80140
80141   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80142   arg2 = (float)jarg2;
80143   {
80144     try {
80145       (arg1)->SetScrollFlickDuration(arg2);
80146     } catch (std::out_of_range& e) {
80147       {
80148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80149       };
80150     } catch (std::exception& e) {
80151       {
80152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80153       };
80154     } catch (Dali::DaliException e) {
80155       {
80156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80157       };
80158     } catch (...) {
80159       {
80160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80161       };
80162     }
80163   }
80164
80165 }
80166
80167
80168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80170   Dali::Toolkit::RulerPtr arg2 ;
80171   Dali::Toolkit::RulerPtr *argp2 ;
80172
80173   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80174   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80175   if (!argp2) {
80176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80177     return ;
80178   }
80179   arg2 = *argp2;
80180   {
80181     try {
80182       (arg1)->SetRulerX(arg2);
80183     } catch (std::out_of_range& e) {
80184       {
80185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80186       };
80187     } catch (std::exception& e) {
80188       {
80189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80190       };
80191     } catch (Dali::DaliException e) {
80192       {
80193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80194       };
80195     } catch (...) {
80196       {
80197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80198       };
80199     }
80200   }
80201
80202 }
80203
80204
80205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80207   Dali::Toolkit::RulerPtr arg2 ;
80208   Dali::Toolkit::RulerPtr *argp2 ;
80209
80210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80211   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80212   if (!argp2) {
80213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80214     return ;
80215   }
80216   arg2 = *argp2;
80217   {
80218     try {
80219       (arg1)->SetRulerY(arg2);
80220     } catch (std::out_of_range& e) {
80221       {
80222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80223       };
80224     } catch (std::exception& e) {
80225       {
80226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80227       };
80228     } catch (Dali::DaliException e) {
80229       {
80230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80231       };
80232     } catch (...) {
80233       {
80234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80235       };
80236     }
80237   }
80238
80239 }
80240
80241
80242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80243   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80244   bool arg2 ;
80245
80246   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80247   arg2 = jarg2 ? true : false;
80248   {
80249     try {
80250       (arg1)->SetScrollSensitive(arg2);
80251     } catch (std::out_of_range& e) {
80252       {
80253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80254       };
80255     } catch (std::exception& e) {
80256       {
80257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80258       };
80259     } catch (Dali::DaliException e) {
80260       {
80261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80262       };
80263     } catch (...) {
80264       {
80265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80266       };
80267     }
80268   }
80269
80270 }
80271
80272
80273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80275   float arg2 ;
80276   float arg3 ;
80277
80278   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80279   arg2 = (float)jarg2;
80280   arg3 = (float)jarg3;
80281   {
80282     try {
80283       (arg1)->SetMaxOvershoot(arg2,arg3);
80284     } catch (std::out_of_range& e) {
80285       {
80286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80287       };
80288     } catch (std::exception& e) {
80289       {
80290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80291       };
80292     } catch (Dali::DaliException e) {
80293       {
80294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80295       };
80296     } catch (...) {
80297       {
80298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80299       };
80300     }
80301   }
80302
80303 }
80304
80305
80306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80307   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80308   Dali::AlphaFunction arg2 ;
80309   Dali::AlphaFunction *argp2 ;
80310
80311   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80312   argp2 = (Dali::AlphaFunction *)jarg2;
80313   if (!argp2) {
80314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80315     return ;
80316   }
80317   arg2 = *argp2;
80318   {
80319     try {
80320       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80321     } catch (std::out_of_range& e) {
80322       {
80323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80324       };
80325     } catch (std::exception& e) {
80326       {
80327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80328       };
80329     } catch (Dali::DaliException e) {
80330       {
80331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80332       };
80333     } catch (...) {
80334       {
80335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80336       };
80337     }
80338   }
80339
80340 }
80341
80342
80343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80344   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80345   float arg2 ;
80346
80347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80348   arg2 = (float)jarg2;
80349   {
80350     try {
80351       (arg1)->SetSnapOvershootDuration(arg2);
80352     } catch (std::out_of_range& e) {
80353       {
80354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80355       };
80356     } catch (std::exception& e) {
80357       {
80358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80359       };
80360     } catch (Dali::DaliException e) {
80361       {
80362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80363       };
80364     } catch (...) {
80365       {
80366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80367       };
80368     }
80369   }
80370
80371 }
80372
80373
80374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80375   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80376   bool arg2 ;
80377
80378   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80379   arg2 = jarg2 ? true : false;
80380   {
80381     try {
80382       (arg1)->SetActorAutoSnap(arg2);
80383     } catch (std::out_of_range& e) {
80384       {
80385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80386       };
80387     } catch (std::exception& e) {
80388       {
80389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80390       };
80391     } catch (Dali::DaliException e) {
80392       {
80393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80394       };
80395     } catch (...) {
80396       {
80397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80398       };
80399     }
80400   }
80401
80402 }
80403
80404
80405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80406   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80407   bool arg2 ;
80408
80409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80410   arg2 = jarg2 ? true : false;
80411   {
80412     try {
80413       (arg1)->SetWrapMode(arg2);
80414     } catch (std::out_of_range& e) {
80415       {
80416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80417       };
80418     } catch (std::exception& e) {
80419       {
80420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80421       };
80422     } catch (Dali::DaliException e) {
80423       {
80424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80425       };
80426     } catch (...) {
80427       {
80428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80429       };
80430     }
80431   }
80432
80433 }
80434
80435
80436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80437   int jresult ;
80438   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80439   int result;
80440
80441   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80442   {
80443     try {
80444       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80445     } catch (std::out_of_range& e) {
80446       {
80447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80448       };
80449     } catch (std::exception& e) {
80450       {
80451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80452       };
80453     } catch (Dali::DaliException e) {
80454       {
80455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80456       };
80457     } catch (...) {
80458       {
80459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80460       };
80461     }
80462   }
80463
80464   jresult = result;
80465   return jresult;
80466 }
80467
80468
80469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80470   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80471   int arg2 ;
80472
80473   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80474   arg2 = (int)jarg2;
80475   {
80476     try {
80477       (arg1)->SetScrollUpdateDistance(arg2);
80478     } catch (std::out_of_range& e) {
80479       {
80480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80481       };
80482     } catch (std::exception& e) {
80483       {
80484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80485       };
80486     } catch (Dali::DaliException e) {
80487       {
80488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80489       };
80490     } catch (...) {
80491       {
80492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80493       };
80494     }
80495   }
80496
80497 }
80498
80499
80500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80501   unsigned int jresult ;
80502   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80503   bool result;
80504
80505   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80506   {
80507     try {
80508       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80509     } catch (std::out_of_range& e) {
80510       {
80511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80512       };
80513     } catch (std::exception& e) {
80514       {
80515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80516       };
80517     } catch (Dali::DaliException e) {
80518       {
80519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80520       };
80521     } catch (...) {
80522       {
80523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80524       };
80525     }
80526   }
80527
80528   jresult = result;
80529   return jresult;
80530 }
80531
80532
80533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80534   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80535   bool arg2 ;
80536
80537   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80538   arg2 = jarg2 ? true : false;
80539   {
80540     try {
80541       (arg1)->SetAxisAutoLock(arg2);
80542     } catch (std::out_of_range& e) {
80543       {
80544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80545       };
80546     } catch (std::exception& e) {
80547       {
80548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80549       };
80550     } catch (Dali::DaliException e) {
80551       {
80552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80553       };
80554     } catch (...) {
80555       {
80556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80557       };
80558     }
80559   }
80560
80561 }
80562
80563
80564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80565   float jresult ;
80566   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80567   float result;
80568
80569   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80570   {
80571     try {
80572       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80573     } catch (std::out_of_range& e) {
80574       {
80575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80576       };
80577     } catch (std::exception& e) {
80578       {
80579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80580       };
80581     } catch (Dali::DaliException e) {
80582       {
80583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80584       };
80585     } catch (...) {
80586       {
80587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80588       };
80589     }
80590   }
80591
80592   jresult = result;
80593   return jresult;
80594 }
80595
80596
80597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80598   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80599   float arg2 ;
80600
80601   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80602   arg2 = (float)jarg2;
80603   {
80604     try {
80605       (arg1)->SetAxisAutoLockGradient(arg2);
80606     } catch (std::out_of_range& e) {
80607       {
80608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80609       };
80610     } catch (std::exception& e) {
80611       {
80612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80613       };
80614     } catch (Dali::DaliException e) {
80615       {
80616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80617       };
80618     } catch (...) {
80619       {
80620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80621       };
80622     }
80623   }
80624
80625 }
80626
80627
80628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80629   float jresult ;
80630   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80631   float result;
80632
80633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80634   {
80635     try {
80636       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80637     } catch (std::out_of_range& e) {
80638       {
80639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80640       };
80641     } catch (std::exception& e) {
80642       {
80643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80644       };
80645     } catch (Dali::DaliException e) {
80646       {
80647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80648       };
80649     } catch (...) {
80650       {
80651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80652       };
80653     }
80654   }
80655
80656   jresult = result;
80657   return jresult;
80658 }
80659
80660
80661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80662   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80663   float arg2 ;
80664
80665   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80666   arg2 = (float)jarg2;
80667   {
80668     try {
80669       (arg1)->SetFrictionCoefficient(arg2);
80670     } catch (std::out_of_range& e) {
80671       {
80672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80673       };
80674     } catch (std::exception& e) {
80675       {
80676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80677       };
80678     } catch (Dali::DaliException e) {
80679       {
80680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80681       };
80682     } catch (...) {
80683       {
80684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80685       };
80686     }
80687   }
80688
80689 }
80690
80691
80692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80693   float jresult ;
80694   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80695   float result;
80696
80697   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80698   {
80699     try {
80700       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80701     } catch (std::out_of_range& e) {
80702       {
80703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80704       };
80705     } catch (std::exception& e) {
80706       {
80707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80708       };
80709     } catch (Dali::DaliException e) {
80710       {
80711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80712       };
80713     } catch (...) {
80714       {
80715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80716       };
80717     }
80718   }
80719
80720   jresult = result;
80721   return jresult;
80722 }
80723
80724
80725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80726   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80727   float arg2 ;
80728
80729   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80730   arg2 = (float)jarg2;
80731   {
80732     try {
80733       (arg1)->SetFlickSpeedCoefficient(arg2);
80734     } catch (std::out_of_range& e) {
80735       {
80736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80737       };
80738     } catch (std::exception& e) {
80739       {
80740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80741       };
80742     } catch (Dali::DaliException e) {
80743       {
80744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80745       };
80746     } catch (...) {
80747       {
80748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80749       };
80750     }
80751   }
80752
80753 }
80754
80755
80756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80757   void * jresult ;
80758   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80759   Dali::Vector2 result;
80760
80761   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80762   {
80763     try {
80764       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80765     } catch (std::out_of_range& e) {
80766       {
80767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80768       };
80769     } catch (std::exception& e) {
80770       {
80771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80772       };
80773     } catch (Dali::DaliException e) {
80774       {
80775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80776       };
80777     } catch (...) {
80778       {
80779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80780       };
80781     }
80782   }
80783
80784   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80785   return jresult;
80786 }
80787
80788
80789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80790   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80791   Dali::Vector2 *arg2 = 0 ;
80792
80793   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80794   arg2 = (Dali::Vector2 *)jarg2;
80795   if (!arg2) {
80796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80797     return ;
80798   }
80799   {
80800     try {
80801       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80802     } catch (std::out_of_range& e) {
80803       {
80804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80805       };
80806     } catch (std::exception& e) {
80807       {
80808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80809       };
80810     } catch (Dali::DaliException e) {
80811       {
80812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80813       };
80814     } catch (...) {
80815       {
80816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80817       };
80818     }
80819   }
80820
80821 }
80822
80823
80824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80825   float jresult ;
80826   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80827   float result;
80828
80829   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80830   {
80831     try {
80832       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
80833     } catch (std::out_of_range& e) {
80834       {
80835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80836       };
80837     } catch (std::exception& e) {
80838       {
80839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80840       };
80841     } catch (Dali::DaliException e) {
80842       {
80843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80844       };
80845     } catch (...) {
80846       {
80847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80848       };
80849     }
80850   }
80851
80852   jresult = result;
80853   return jresult;
80854 }
80855
80856
80857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
80858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80859   float arg2 ;
80860
80861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80862   arg2 = (float)jarg2;
80863   {
80864     try {
80865       (arg1)->SetMinimumSpeedForFlick(arg2);
80866     } catch (std::out_of_range& e) {
80867       {
80868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80869       };
80870     } catch (std::exception& e) {
80871       {
80872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80873       };
80874     } catch (Dali::DaliException e) {
80875       {
80876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80877       };
80878     } catch (...) {
80879       {
80880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80881       };
80882     }
80883   }
80884
80885 }
80886
80887
80888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
80889   float jresult ;
80890   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80891   float result;
80892
80893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80894   {
80895     try {
80896       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80897     } catch (std::out_of_range& e) {
80898       {
80899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80900       };
80901     } catch (std::exception& e) {
80902       {
80903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80904       };
80905     } catch (Dali::DaliException e) {
80906       {
80907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80908       };
80909     } catch (...) {
80910       {
80911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80912       };
80913     }
80914   }
80915
80916   jresult = result;
80917   return jresult;
80918 }
80919
80920
80921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80922   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80923   float arg2 ;
80924
80925   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80926   arg2 = (float)jarg2;
80927   {
80928     try {
80929       (arg1)->SetMaxFlickSpeed(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_GetWheelScrollDistanceStep(void * jarg1) {
80953   void * jresult ;
80954   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80955   Dali::Vector2 result;
80956
80957   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80958   {
80959     try {
80960       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80961     } catch (std::out_of_range& e) {
80962       {
80963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80964       };
80965     } catch (std::exception& e) {
80966       {
80967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80968       };
80969     } catch (Dali::DaliException e) {
80970       {
80971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80972       };
80973     } catch (...) {
80974       {
80975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80976       };
80977     }
80978   }
80979
80980   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80981   return jresult;
80982 }
80983
80984
80985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80987   Dali::Vector2 arg2 ;
80988   Dali::Vector2 *argp2 ;
80989
80990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80991   argp2 = (Dali::Vector2 *)jarg2;
80992   if (!argp2) {
80993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80994     return ;
80995   }
80996   arg2 = *argp2;
80997   {
80998     try {
80999       (arg1)->SetWheelScrollDistanceStep(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_GetCurrentScrollPosition(void * jarg1) {
81023   void * jresult ;
81024   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81025   Dali::Vector2 result;
81026
81027   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81028   {
81029     try {
81030       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81031     } catch (std::out_of_range& e) {
81032       {
81033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81034       };
81035     } catch (std::exception& e) {
81036       {
81037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81038       };
81039     } catch (Dali::DaliException e) {
81040       {
81041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81042       };
81043     } catch (...) {
81044       {
81045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81046       };
81047     }
81048   }
81049
81050   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81051   return jresult;
81052 }
81053
81054
81055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81056   unsigned int jresult ;
81057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81058   unsigned int result;
81059
81060   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81061   {
81062     try {
81063       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81064     } catch (std::out_of_range& e) {
81065       {
81066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81067       };
81068     } catch (std::exception& e) {
81069       {
81070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81071       };
81072     } catch (Dali::DaliException e) {
81073       {
81074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81075       };
81076     } catch (...) {
81077       {
81078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81079       };
81080     }
81081   }
81082
81083   jresult = result;
81084   return jresult;
81085 }
81086
81087
81088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81089   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81090   Dali::Vector2 *arg2 = 0 ;
81091
81092   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81093   arg2 = (Dali::Vector2 *)jarg2;
81094   if (!arg2) {
81095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81096     return ;
81097   }
81098   {
81099     try {
81100       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81101     } catch (std::out_of_range& e) {
81102       {
81103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81104       };
81105     } catch (std::exception& e) {
81106       {
81107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81108       };
81109     } catch (Dali::DaliException e) {
81110       {
81111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81112       };
81113     } catch (...) {
81114       {
81115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81116       };
81117     }
81118   }
81119
81120 }
81121
81122
81123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81124   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81125   Dali::Vector2 *arg2 = 0 ;
81126   float arg3 ;
81127
81128   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81129   arg2 = (Dali::Vector2 *)jarg2;
81130   if (!arg2) {
81131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81132     return ;
81133   }
81134   arg3 = (float)jarg3;
81135   {
81136     try {
81137       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81138     } catch (std::out_of_range& e) {
81139       {
81140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81141       };
81142     } catch (std::exception& e) {
81143       {
81144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81145       };
81146     } catch (Dali::DaliException e) {
81147       {
81148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81149       };
81150     } catch (...) {
81151       {
81152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81153       };
81154     }
81155   }
81156
81157 }
81158
81159
81160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81161   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81162   Dali::Vector2 *arg2 = 0 ;
81163   float arg3 ;
81164   Dali::AlphaFunction arg4 ;
81165   Dali::AlphaFunction *argp4 ;
81166
81167   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81168   arg2 = (Dali::Vector2 *)jarg2;
81169   if (!arg2) {
81170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81171     return ;
81172   }
81173   arg3 = (float)jarg3;
81174   argp4 = (Dali::AlphaFunction *)jarg4;
81175   if (!argp4) {
81176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81177     return ;
81178   }
81179   arg4 = *argp4;
81180   {
81181     try {
81182       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81183     } catch (std::out_of_range& e) {
81184       {
81185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81186       };
81187     } catch (std::exception& e) {
81188       {
81189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81190       };
81191     } catch (Dali::DaliException e) {
81192       {
81193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81194       };
81195     } catch (...) {
81196       {
81197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81198       };
81199     }
81200   }
81201
81202 }
81203
81204
81205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81207   Dali::Vector2 *arg2 = 0 ;
81208   float arg3 ;
81209   Dali::Toolkit::DirectionBias arg4 ;
81210   Dali::Toolkit::DirectionBias arg5 ;
81211
81212   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81213   arg2 = (Dali::Vector2 *)jarg2;
81214   if (!arg2) {
81215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81216     return ;
81217   }
81218   arg3 = (float)jarg3;
81219   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81220   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81221   {
81222     try {
81223       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81224     } catch (std::out_of_range& e) {
81225       {
81226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81227       };
81228     } catch (std::exception& e) {
81229       {
81230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81231       };
81232     } catch (Dali::DaliException e) {
81233       {
81234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81235       };
81236     } catch (...) {
81237       {
81238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81239       };
81240     }
81241   }
81242
81243 }
81244
81245
81246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81247   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81248   Dali::Vector2 *arg2 = 0 ;
81249   float arg3 ;
81250   Dali::AlphaFunction arg4 ;
81251   Dali::Toolkit::DirectionBias arg5 ;
81252   Dali::Toolkit::DirectionBias arg6 ;
81253   Dali::AlphaFunction *argp4 ;
81254
81255   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81256   arg2 = (Dali::Vector2 *)jarg2;
81257   if (!arg2) {
81258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81259     return ;
81260   }
81261   arg3 = (float)jarg3;
81262   argp4 = (Dali::AlphaFunction *)jarg4;
81263   if (!argp4) {
81264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81265     return ;
81266   }
81267   arg4 = *argp4;
81268   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81269   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81270   {
81271     try {
81272       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81273     } catch (std::out_of_range& e) {
81274       {
81275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81276       };
81277     } catch (std::exception& e) {
81278       {
81279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81280       };
81281     } catch (Dali::DaliException e) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81284       };
81285     } catch (...) {
81286       {
81287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81288       };
81289     }
81290   }
81291
81292 }
81293
81294
81295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81296   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81297   unsigned int arg2 ;
81298
81299   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81300   arg2 = (unsigned int)jarg2;
81301   {
81302     try {
81303       (arg1)->ScrollTo(arg2);
81304     } catch (std::out_of_range& e) {
81305       {
81306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81307       };
81308     } catch (std::exception& e) {
81309       {
81310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81311       };
81312     } catch (Dali::DaliException e) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81315       };
81316     } catch (...) {
81317       {
81318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81319       };
81320     }
81321   }
81322
81323 }
81324
81325
81326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81327   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81328   unsigned int arg2 ;
81329   float arg3 ;
81330
81331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81332   arg2 = (unsigned int)jarg2;
81333   arg3 = (float)jarg3;
81334   {
81335     try {
81336       (arg1)->ScrollTo(arg2,arg3);
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81344       };
81345     } catch (Dali::DaliException e) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81348       };
81349     } catch (...) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81352       };
81353     }
81354   }
81355
81356 }
81357
81358
81359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81361   unsigned int arg2 ;
81362   float arg3 ;
81363   Dali::Toolkit::DirectionBias arg4 ;
81364
81365   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81366   arg2 = (unsigned int)jarg2;
81367   arg3 = (float)jarg3;
81368   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81369   {
81370     try {
81371       (arg1)->ScrollTo(arg2,arg3,arg4);
81372     } catch (std::out_of_range& e) {
81373       {
81374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81375       };
81376     } catch (std::exception& e) {
81377       {
81378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81379       };
81380     } catch (Dali::DaliException e) {
81381       {
81382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81383       };
81384     } catch (...) {
81385       {
81386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81387       };
81388     }
81389   }
81390
81391 }
81392
81393
81394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81395   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81396   Dali::Actor *arg2 = 0 ;
81397
81398   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81399   arg2 = (Dali::Actor *)jarg2;
81400   if (!arg2) {
81401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81402     return ;
81403   }
81404   {
81405     try {
81406       (arg1)->ScrollTo(*arg2);
81407     } catch (std::out_of_range& e) {
81408       {
81409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81410       };
81411     } catch (std::exception& e) {
81412       {
81413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81414       };
81415     } catch (Dali::DaliException e) {
81416       {
81417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81418       };
81419     } catch (...) {
81420       {
81421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81422       };
81423     }
81424   }
81425
81426 }
81427
81428
81429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81430   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81431   Dali::Actor *arg2 = 0 ;
81432   float arg3 ;
81433
81434   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81435   arg2 = (Dali::Actor *)jarg2;
81436   if (!arg2) {
81437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81438     return ;
81439   }
81440   arg3 = (float)jarg3;
81441   {
81442     try {
81443       (arg1)->ScrollTo(*arg2,arg3);
81444     } catch (std::out_of_range& e) {
81445       {
81446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81447       };
81448     } catch (std::exception& e) {
81449       {
81450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81451       };
81452     } catch (Dali::DaliException e) {
81453       {
81454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81455       };
81456     } catch (...) {
81457       {
81458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81459       };
81460     }
81461   }
81462
81463 }
81464
81465
81466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81467   unsigned int jresult ;
81468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81469   bool result;
81470
81471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81472   {
81473     try {
81474       result = (bool)(arg1)->ScrollToSnapPoint();
81475     } catch (std::out_of_range& e) {
81476       {
81477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81478       };
81479     } catch (std::exception& e) {
81480       {
81481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81482       };
81483     } catch (Dali::DaliException e) {
81484       {
81485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81486       };
81487     } catch (...) {
81488       {
81489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81490       };
81491     }
81492   }
81493
81494   jresult = result;
81495   return jresult;
81496 }
81497
81498
81499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81500   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81501   Dali::Constraint arg2 ;
81502   Dali::Constraint *argp2 ;
81503
81504   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81505   argp2 = (Dali::Constraint *)jarg2;
81506   if (!argp2) {
81507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81508     return ;
81509   }
81510   arg2 = *argp2;
81511   {
81512     try {
81513       (arg1)->ApplyConstraintToChildren(arg2);
81514     } catch (std::out_of_range& e) {
81515       {
81516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81517       };
81518     } catch (std::exception& e) {
81519       {
81520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81521       };
81522     } catch (Dali::DaliException e) {
81523       {
81524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81525       };
81526     } catch (...) {
81527       {
81528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81529       };
81530     }
81531   }
81532
81533 }
81534
81535
81536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81538
81539   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81540   {
81541     try {
81542       (arg1)->RemoveConstraintsFromChildren();
81543     } catch (std::out_of_range& e) {
81544       {
81545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81546       };
81547     } catch (std::exception& e) {
81548       {
81549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81550       };
81551     } catch (Dali::DaliException e) {
81552       {
81553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81554       };
81555     } catch (...) {
81556       {
81557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81558       };
81559     }
81560   }
81561
81562 }
81563
81564
81565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81566   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81567   Dali::Toolkit::ScrollViewEffect arg2 ;
81568   Dali::Toolkit::ScrollViewEffect *argp2 ;
81569
81570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81571   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81572   if (!argp2) {
81573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81574     return ;
81575   }
81576   arg2 = *argp2;
81577   {
81578     try {
81579       (arg1)->ApplyEffect(arg2);
81580     } catch (std::out_of_range& e) {
81581       {
81582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81583       };
81584     } catch (std::exception& e) {
81585       {
81586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81587       };
81588     } catch (Dali::DaliException e) {
81589       {
81590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81591       };
81592     } catch (...) {
81593       {
81594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81595       };
81596     }
81597   }
81598
81599 }
81600
81601
81602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81603   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81604   Dali::Toolkit::ScrollViewEffect arg2 ;
81605   Dali::Toolkit::ScrollViewEffect *argp2 ;
81606
81607   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81608   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81609   if (!argp2) {
81610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81611     return ;
81612   }
81613   arg2 = *argp2;
81614   {
81615     try {
81616       (arg1)->RemoveEffect(arg2);
81617     } catch (std::out_of_range& e) {
81618       {
81619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81620       };
81621     } catch (std::exception& e) {
81622       {
81623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81624       };
81625     } catch (Dali::DaliException e) {
81626       {
81627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81628       };
81629     } catch (...) {
81630       {
81631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81632       };
81633     }
81634   }
81635
81636 }
81637
81638
81639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81640   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81641
81642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81643   {
81644     try {
81645       (arg1)->RemoveAllEffects();
81646     } catch (std::out_of_range& e) {
81647       {
81648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81649       };
81650     } catch (std::exception& e) {
81651       {
81652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81653       };
81654     } catch (Dali::DaliException e) {
81655       {
81656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81657       };
81658     } catch (...) {
81659       {
81660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81661       };
81662     }
81663   }
81664
81665 }
81666
81667
81668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81670   Dali::Actor arg2 ;
81671   Dali::Actor *argp2 ;
81672
81673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81674   argp2 = (Dali::Actor *)jarg2;
81675   if (!argp2) {
81676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81677     return ;
81678   }
81679   arg2 = *argp2;
81680   {
81681     try {
81682       (arg1)->BindActor(arg2);
81683     } catch (std::out_of_range& e) {
81684       {
81685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81686       };
81687     } catch (std::exception& e) {
81688       {
81689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81690       };
81691     } catch (Dali::DaliException e) {
81692       {
81693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81694       };
81695     } catch (...) {
81696       {
81697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81698       };
81699     }
81700   }
81701
81702 }
81703
81704
81705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81706   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81707   Dali::Actor arg2 ;
81708   Dali::Actor *argp2 ;
81709
81710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81711   argp2 = (Dali::Actor *)jarg2;
81712   if (!argp2) {
81713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81714     return ;
81715   }
81716   arg2 = *argp2;
81717   {
81718     try {
81719       (arg1)->UnbindActor(arg2);
81720     } catch (std::out_of_range& e) {
81721       {
81722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81723       };
81724     } catch (std::exception& e) {
81725       {
81726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81727       };
81728     } catch (Dali::DaliException e) {
81729       {
81730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81731       };
81732     } catch (...) {
81733       {
81734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81735       };
81736     }
81737   }
81738
81739 }
81740
81741
81742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81743   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81744   Dali::Radian arg2 ;
81745   Dali::Radian arg3 ;
81746   Dali::Radian *argp2 ;
81747   Dali::Radian *argp3 ;
81748
81749   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81750   argp2 = (Dali::Radian *)jarg2;
81751   if (!argp2) {
81752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81753     return ;
81754   }
81755   arg2 = *argp2;
81756   argp3 = (Dali::Radian *)jarg3;
81757   if (!argp3) {
81758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81759     return ;
81760   }
81761   arg3 = *argp3;
81762   {
81763     try {
81764       (arg1)->SetScrollingDirection(arg2,arg3);
81765     } catch (std::out_of_range& e) {
81766       {
81767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81768       };
81769     } catch (std::exception& e) {
81770       {
81771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81772       };
81773     } catch (Dali::DaliException e) {
81774       {
81775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81776       };
81777     } catch (...) {
81778       {
81779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81780       };
81781     }
81782   }
81783
81784 }
81785
81786
81787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81788   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81789   Dali::Radian arg2 ;
81790   Dali::Radian *argp2 ;
81791
81792   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81793   argp2 = (Dali::Radian *)jarg2;
81794   if (!argp2) {
81795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81796     return ;
81797   }
81798   arg2 = *argp2;
81799   {
81800     try {
81801       (arg1)->SetScrollingDirection(arg2);
81802     } catch (std::out_of_range& e) {
81803       {
81804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81805       };
81806     } catch (std::exception& e) {
81807       {
81808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81809       };
81810     } catch (Dali::DaliException e) {
81811       {
81812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81813       };
81814     } catch (...) {
81815       {
81816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81817       };
81818     }
81819   }
81820
81821 }
81822
81823
81824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81825   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81826   Dali::Radian arg2 ;
81827   Dali::Radian *argp2 ;
81828
81829   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81830   argp2 = (Dali::Radian *)jarg2;
81831   if (!argp2) {
81832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81833     return ;
81834   }
81835   arg2 = *argp2;
81836   {
81837     try {
81838       (arg1)->RemoveScrollingDirection(arg2);
81839     } catch (std::out_of_range& e) {
81840       {
81841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81842       };
81843     } catch (std::exception& e) {
81844       {
81845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81846       };
81847     } catch (Dali::DaliException e) {
81848       {
81849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81850       };
81851     } catch (...) {
81852       {
81853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81854       };
81855     }
81856   }
81857
81858 }
81859
81860
81861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
81862   void * jresult ;
81863   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81864   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
81865
81866   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81867   {
81868     try {
81869       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
81870     } catch (std::out_of_range& e) {
81871       {
81872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81873       };
81874     } catch (std::exception& e) {
81875       {
81876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81877       };
81878     } catch (Dali::DaliException e) {
81879       {
81880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81881       };
81882     } catch (...) {
81883       {
81884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81885       };
81886     }
81887   }
81888
81889   jresult = (void *)result;
81890   return jresult;
81891 }
81892
81893
81894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81895   int jresult ;
81896   int result;
81897
81898   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81899   jresult = (int)result;
81900   return jresult;
81901 }
81902
81903
81904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81905   int jresult ;
81906   int result;
81907
81908   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81909   jresult = (int)result;
81910   return jresult;
81911 }
81912
81913
81914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81915   int jresult ;
81916   int result;
81917
81918   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81919   jresult = (int)result;
81920   return jresult;
81921 }
81922
81923
81924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81925   int jresult ;
81926   int result;
81927
81928   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81929   jresult = (int)result;
81930   return jresult;
81931 }
81932
81933
81934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81935   int jresult ;
81936   int result;
81937
81938   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81939   jresult = (int)result;
81940   return jresult;
81941 }
81942
81943
81944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81945   void * jresult ;
81946   Dali::Toolkit::TableView::Property *result = 0 ;
81947
81948   {
81949     try {
81950       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81951     } catch (std::out_of_range& e) {
81952       {
81953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81954       };
81955     } catch (std::exception& e) {
81956       {
81957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81958       };
81959     } catch (Dali::DaliException e) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81962       };
81963     } catch (...) {
81964       {
81965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81966       };
81967     }
81968   }
81969
81970   jresult = (void *)result;
81971   return jresult;
81972 }
81973
81974
81975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81976   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81977
81978   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81979   {
81980     try {
81981       delete arg1;
81982     } catch (std::out_of_range& e) {
81983       {
81984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81985       };
81986     } catch (std::exception& e) {
81987       {
81988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81989       };
81990     } catch (Dali::DaliException e) {
81991       {
81992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81993       };
81994     } catch (...) {
81995       {
81996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81997       };
81998     }
81999   }
82000
82001 }
82002
82003
82004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82005   int jresult ;
82006   int result;
82007
82008   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82009   jresult = (int)result;
82010   return jresult;
82011 }
82012
82013
82014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82015   int jresult ;
82016   int result;
82017
82018   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82019   jresult = (int)result;
82020   return jresult;
82021 }
82022
82023
82024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82025   int jresult ;
82026   int result;
82027
82028   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82029   jresult = (int)result;
82030   return jresult;
82031 }
82032
82033
82034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82035   int jresult ;
82036   int result;
82037
82038   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82039   jresult = (int)result;
82040   return jresult;
82041 }
82042
82043
82044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82045   int jresult ;
82046   int result;
82047
82048   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82049   jresult = (int)result;
82050   return jresult;
82051 }
82052
82053
82054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82055   void * jresult ;
82056   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82057
82058   {
82059     try {
82060       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82061     } catch (std::out_of_range& e) {
82062       {
82063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82064       };
82065     } catch (std::exception& e) {
82066       {
82067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82068       };
82069     } catch (Dali::DaliException e) {
82070       {
82071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82072       };
82073     } catch (...) {
82074       {
82075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82076       };
82077     }
82078   }
82079
82080   jresult = (void *)result;
82081   return jresult;
82082 }
82083
82084
82085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82086   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82087
82088   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82089   {
82090     try {
82091       delete arg1;
82092     } catch (std::out_of_range& e) {
82093       {
82094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82095       };
82096     } catch (std::exception& e) {
82097       {
82098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82099       };
82100     } catch (Dali::DaliException e) {
82101       {
82102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82103       };
82104     } catch (...) {
82105       {
82106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82107       };
82108     }
82109   }
82110
82111 }
82112
82113
82114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82115   void * jresult ;
82116   unsigned int arg1 ;
82117   unsigned int arg2 ;
82118   unsigned int arg3 ;
82119   unsigned int arg4 ;
82120   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82121
82122   arg1 = (unsigned int)jarg1;
82123   arg2 = (unsigned int)jarg2;
82124   arg3 = (unsigned int)jarg3;
82125   arg4 = (unsigned int)jarg4;
82126   {
82127     try {
82128       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82129     } catch (std::out_of_range& e) {
82130       {
82131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82132       };
82133     } catch (std::exception& e) {
82134       {
82135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82136       };
82137     } catch (Dali::DaliException e) {
82138       {
82139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82140       };
82141     } catch (...) {
82142       {
82143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82144       };
82145     }
82146   }
82147
82148   jresult = (void *)result;
82149   return jresult;
82150 }
82151
82152
82153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82154   void * jresult ;
82155   unsigned int arg1 ;
82156   unsigned int arg2 ;
82157   unsigned int arg3 ;
82158   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82159
82160   arg1 = (unsigned int)jarg1;
82161   arg2 = (unsigned int)jarg2;
82162   arg3 = (unsigned int)jarg3;
82163   {
82164     try {
82165       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82166     } catch (std::out_of_range& e) {
82167       {
82168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82169       };
82170     } catch (std::exception& e) {
82171       {
82172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82173       };
82174     } catch (Dali::DaliException e) {
82175       {
82176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82177       };
82178     } catch (...) {
82179       {
82180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82181       };
82182     }
82183   }
82184
82185   jresult = (void *)result;
82186   return jresult;
82187 }
82188
82189
82190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82191   void * jresult ;
82192   unsigned int arg1 ;
82193   unsigned int arg2 ;
82194   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82195
82196   arg1 = (unsigned int)jarg1;
82197   arg2 = (unsigned int)jarg2;
82198   {
82199     try {
82200       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82201     } catch (std::out_of_range& e) {
82202       {
82203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82204       };
82205     } catch (std::exception& e) {
82206       {
82207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82208       };
82209     } catch (Dali::DaliException e) {
82210       {
82211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82212       };
82213     } catch (...) {
82214       {
82215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82216       };
82217     }
82218   }
82219
82220   jresult = (void *)result;
82221   return jresult;
82222 }
82223
82224
82225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82226   void * jresult ;
82227   unsigned int arg1 ;
82228   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82229
82230   arg1 = (unsigned int)jarg1;
82231   {
82232     try {
82233       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82234     } catch (std::out_of_range& e) {
82235       {
82236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82237       };
82238     } catch (std::exception& e) {
82239       {
82240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82241       };
82242     } catch (Dali::DaliException e) {
82243       {
82244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82245       };
82246     } catch (...) {
82247       {
82248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82249       };
82250     }
82251   }
82252
82253   jresult = (void *)result;
82254   return jresult;
82255 }
82256
82257
82258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82259   void * jresult ;
82260   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82261
82262   {
82263     try {
82264       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82265     } catch (std::out_of_range& e) {
82266       {
82267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82268       };
82269     } catch (std::exception& e) {
82270       {
82271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82272       };
82273     } catch (Dali::DaliException e) {
82274       {
82275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82276       };
82277     } catch (...) {
82278       {
82279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82280       };
82281     }
82282   }
82283
82284   jresult = (void *)result;
82285   return jresult;
82286 }
82287
82288
82289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82290   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82291   unsigned int arg2 ;
82292
82293   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82294   arg2 = (unsigned int)jarg2;
82295   if (arg1) (arg1)->rowIndex = arg2;
82296 }
82297
82298
82299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82300   unsigned int jresult ;
82301   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82302   unsigned int result;
82303
82304   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82305   result = (unsigned int) ((arg1)->rowIndex);
82306   jresult = result;
82307   return jresult;
82308 }
82309
82310
82311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82312   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82313   unsigned int arg2 ;
82314
82315   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82316   arg2 = (unsigned int)jarg2;
82317   if (arg1) (arg1)->columnIndex = arg2;
82318 }
82319
82320
82321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82322   unsigned int jresult ;
82323   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82324   unsigned int result;
82325
82326   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82327   result = (unsigned int) ((arg1)->columnIndex);
82328   jresult = result;
82329   return jresult;
82330 }
82331
82332
82333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82334   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82335   unsigned int arg2 ;
82336
82337   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82338   arg2 = (unsigned int)jarg2;
82339   if (arg1) (arg1)->rowSpan = arg2;
82340 }
82341
82342
82343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82344   unsigned int jresult ;
82345   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82346   unsigned int result;
82347
82348   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82349   result = (unsigned int) ((arg1)->rowSpan);
82350   jresult = result;
82351   return jresult;
82352 }
82353
82354
82355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82356   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82357   unsigned int arg2 ;
82358
82359   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82360   arg2 = (unsigned int)jarg2;
82361   if (arg1) (arg1)->columnSpan = arg2;
82362 }
82363
82364
82365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82366   unsigned int jresult ;
82367   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82368   unsigned int result;
82369
82370   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82371   result = (unsigned int) ((arg1)->columnSpan);
82372   jresult = result;
82373   return jresult;
82374 }
82375
82376
82377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82378   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82379
82380   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82381   {
82382     try {
82383       delete arg1;
82384     } catch (std::out_of_range& e) {
82385       {
82386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82387       };
82388     } catch (std::exception& e) {
82389       {
82390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82391       };
82392     } catch (Dali::DaliException e) {
82393       {
82394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82395       };
82396     } catch (...) {
82397       {
82398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82399       };
82400     }
82401   }
82402
82403 }
82404
82405
82406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82407   void * jresult ;
82408   Dali::Toolkit::TableView *result = 0 ;
82409
82410   {
82411     try {
82412       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82413     } catch (std::out_of_range& e) {
82414       {
82415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82416       };
82417     } catch (std::exception& e) {
82418       {
82419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82420       };
82421     } catch (Dali::DaliException e) {
82422       {
82423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82424       };
82425     } catch (...) {
82426       {
82427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82428       };
82429     }
82430   }
82431
82432   jresult = (void *)result;
82433   return jresult;
82434 }
82435
82436
82437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82438   void * jresult ;
82439   Dali::Toolkit::TableView *arg1 = 0 ;
82440   Dali::Toolkit::TableView *result = 0 ;
82441
82442   arg1 = (Dali::Toolkit::TableView *)jarg1;
82443   if (!arg1) {
82444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82445     return 0;
82446   }
82447   {
82448     try {
82449       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82450     } catch (std::out_of_range& e) {
82451       {
82452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82453       };
82454     } catch (std::exception& e) {
82455       {
82456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82457       };
82458     } catch (Dali::DaliException e) {
82459       {
82460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82461       };
82462     } catch (...) {
82463       {
82464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82465       };
82466     }
82467   }
82468
82469   jresult = (void *)result;
82470   return jresult;
82471 }
82472
82473
82474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82475   void * jresult ;
82476   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82477   Dali::Toolkit::TableView *arg2 = 0 ;
82478   Dali::Toolkit::TableView *result = 0 ;
82479
82480   arg1 = (Dali::Toolkit::TableView *)jarg1;
82481   arg2 = (Dali::Toolkit::TableView *)jarg2;
82482   if (!arg2) {
82483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82484     return 0;
82485   }
82486   {
82487     try {
82488       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82489     } catch (std::out_of_range& e) {
82490       {
82491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82492       };
82493     } catch (std::exception& e) {
82494       {
82495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82496       };
82497     } catch (Dali::DaliException e) {
82498       {
82499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82500       };
82501     } catch (...) {
82502       {
82503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82504       };
82505     }
82506   }
82507
82508   jresult = (void *)result;
82509   return jresult;
82510 }
82511
82512
82513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82514   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82515
82516   arg1 = (Dali::Toolkit::TableView *)jarg1;
82517   {
82518     try {
82519       delete arg1;
82520     } catch (std::out_of_range& e) {
82521       {
82522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82523       };
82524     } catch (std::exception& e) {
82525       {
82526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82527       };
82528     } catch (Dali::DaliException e) {
82529       {
82530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82531       };
82532     } catch (...) {
82533       {
82534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82535       };
82536     }
82537   }
82538
82539 }
82540
82541
82542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82543   void * jresult ;
82544   unsigned int arg1 ;
82545   unsigned int arg2 ;
82546   Dali::Toolkit::TableView result;
82547
82548   arg1 = (unsigned int)jarg1;
82549   arg2 = (unsigned int)jarg2;
82550   {
82551     try {
82552       result = Dali::Toolkit::TableView::New(arg1,arg2);
82553     } catch (std::out_of_range& e) {
82554       {
82555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82556       };
82557     } catch (std::exception& e) {
82558       {
82559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82560       };
82561     } catch (Dali::DaliException e) {
82562       {
82563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82564       };
82565     } catch (...) {
82566       {
82567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82568       };
82569     }
82570   }
82571
82572   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82573   return jresult;
82574 }
82575
82576
82577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82578   void * jresult ;
82579   Dali::BaseHandle arg1 ;
82580   Dali::BaseHandle *argp1 ;
82581   Dali::Toolkit::TableView result;
82582
82583   argp1 = (Dali::BaseHandle *)jarg1;
82584   if (!argp1) {
82585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82586     return 0;
82587   }
82588   arg1 = *argp1;
82589   {
82590     try {
82591       result = Dali::Toolkit::TableView::DownCast(arg1);
82592     } catch (std::out_of_range& e) {
82593       {
82594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82595       };
82596     } catch (std::exception& e) {
82597       {
82598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82599       };
82600     } catch (Dali::DaliException e) {
82601       {
82602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82603       };
82604     } catch (...) {
82605       {
82606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82607       };
82608     }
82609   }
82610
82611   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82612   return jresult;
82613 }
82614
82615
82616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82617   unsigned int jresult ;
82618   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82619   Dali::Actor arg2 ;
82620   Dali::Toolkit::TableView::CellPosition arg3 ;
82621   Dali::Actor *argp2 ;
82622   Dali::Toolkit::TableView::CellPosition *argp3 ;
82623   bool result;
82624
82625   arg1 = (Dali::Toolkit::TableView *)jarg1;
82626   argp2 = (Dali::Actor *)jarg2;
82627   if (!argp2) {
82628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82629     return 0;
82630   }
82631   arg2 = *argp2;
82632   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82633   if (!argp3) {
82634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82635     return 0;
82636   }
82637   arg3 = *argp3;
82638   {
82639     try {
82640       result = (bool)(arg1)->AddChild(arg2,arg3);
82641     } catch (std::out_of_range& e) {
82642       {
82643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82644       };
82645     } catch (std::exception& e) {
82646       {
82647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82648       };
82649     } catch (Dali::DaliException e) {
82650       {
82651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82652       };
82653     } catch (...) {
82654       {
82655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82656       };
82657     }
82658   }
82659
82660   jresult = result;
82661   return jresult;
82662 }
82663
82664
82665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82666   void * jresult ;
82667   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82668   Dali::Toolkit::TableView::CellPosition arg2 ;
82669   Dali::Toolkit::TableView::CellPosition *argp2 ;
82670   Dali::Actor result;
82671
82672   arg1 = (Dali::Toolkit::TableView *)jarg1;
82673   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82674   if (!argp2) {
82675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82676     return 0;
82677   }
82678   arg2 = *argp2;
82679   {
82680     try {
82681       result = (arg1)->GetChildAt(arg2);
82682     } catch (std::out_of_range& e) {
82683       {
82684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82685       };
82686     } catch (std::exception& e) {
82687       {
82688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82689       };
82690     } catch (Dali::DaliException e) {
82691       {
82692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82693       };
82694     } catch (...) {
82695       {
82696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82697       };
82698     }
82699   }
82700
82701   jresult = new Dali::Actor((const Dali::Actor &)result);
82702   return jresult;
82703 }
82704
82705
82706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82707   void * jresult ;
82708   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82709   Dali::Toolkit::TableView::CellPosition arg2 ;
82710   Dali::Toolkit::TableView::CellPosition *argp2 ;
82711   Dali::Actor result;
82712
82713   arg1 = (Dali::Toolkit::TableView *)jarg1;
82714   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82715   if (!argp2) {
82716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82717     return 0;
82718   }
82719   arg2 = *argp2;
82720   {
82721     try {
82722       result = (arg1)->RemoveChildAt(arg2);
82723     } catch (std::out_of_range& e) {
82724       {
82725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82726       };
82727     } catch (std::exception& e) {
82728       {
82729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82730       };
82731     } catch (Dali::DaliException e) {
82732       {
82733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82734       };
82735     } catch (...) {
82736       {
82737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82738       };
82739     }
82740   }
82741
82742   jresult = new Dali::Actor((const Dali::Actor &)result);
82743   return jresult;
82744 }
82745
82746
82747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82748   unsigned int jresult ;
82749   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82750   Dali::Actor arg2 ;
82751   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82752   Dali::Actor *argp2 ;
82753   bool result;
82754
82755   arg1 = (Dali::Toolkit::TableView *)jarg1;
82756   argp2 = (Dali::Actor *)jarg2;
82757   if (!argp2) {
82758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82759     return 0;
82760   }
82761   arg2 = *argp2;
82762   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82763   if (!arg3) {
82764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82765     return 0;
82766   }
82767   {
82768     try {
82769       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82770     } catch (std::out_of_range& e) {
82771       {
82772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82773       };
82774     } catch (std::exception& e) {
82775       {
82776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82777       };
82778     } catch (Dali::DaliException e) {
82779       {
82780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82781       };
82782     } catch (...) {
82783       {
82784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82785       };
82786     }
82787   }
82788
82789   jresult = result;
82790   return jresult;
82791 }
82792
82793
82794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82795   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82796   unsigned int arg2 ;
82797
82798   arg1 = (Dali::Toolkit::TableView *)jarg1;
82799   arg2 = (unsigned int)jarg2;
82800   {
82801     try {
82802       (arg1)->InsertRow(arg2);
82803     } catch (std::out_of_range& e) {
82804       {
82805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82806       };
82807     } catch (std::exception& e) {
82808       {
82809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82810       };
82811     } catch (Dali::DaliException e) {
82812       {
82813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82814       };
82815     } catch (...) {
82816       {
82817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82818       };
82819     }
82820   }
82821
82822 }
82823
82824
82825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82826   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82827   unsigned int arg2 ;
82828
82829   arg1 = (Dali::Toolkit::TableView *)jarg1;
82830   arg2 = (unsigned int)jarg2;
82831   {
82832     try {
82833       (arg1)->DeleteRow(arg2);
82834     } catch (std::out_of_range& e) {
82835       {
82836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82837       };
82838     } catch (std::exception& e) {
82839       {
82840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82841       };
82842     } catch (Dali::DaliException e) {
82843       {
82844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82845       };
82846     } catch (...) {
82847       {
82848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82849       };
82850     }
82851   }
82852
82853 }
82854
82855
82856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82857   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82858   unsigned int arg2 ;
82859   std::vector< Dali::Actor > *arg3 = 0 ;
82860
82861   arg1 = (Dali::Toolkit::TableView *)jarg1;
82862   arg2 = (unsigned int)jarg2;
82863   arg3 = (std::vector< Dali::Actor > *)jarg3;
82864   if (!arg3) {
82865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82866     return ;
82867   }
82868   {
82869     try {
82870       (arg1)->DeleteRow(arg2,*arg3);
82871     } catch (std::out_of_range& e) {
82872       {
82873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82874       };
82875     } catch (std::exception& e) {
82876       {
82877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82878       };
82879     } catch (Dali::DaliException e) {
82880       {
82881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82882       };
82883     } catch (...) {
82884       {
82885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82886       };
82887     }
82888   }
82889
82890 }
82891
82892
82893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82894   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82895   unsigned int arg2 ;
82896
82897   arg1 = (Dali::Toolkit::TableView *)jarg1;
82898   arg2 = (unsigned int)jarg2;
82899   {
82900     try {
82901       (arg1)->InsertColumn(arg2);
82902     } catch (std::out_of_range& e) {
82903       {
82904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82905       };
82906     } catch (std::exception& e) {
82907       {
82908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82909       };
82910     } catch (Dali::DaliException e) {
82911       {
82912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82913       };
82914     } catch (...) {
82915       {
82916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82917       };
82918     }
82919   }
82920
82921 }
82922
82923
82924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82925   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82926   unsigned int arg2 ;
82927
82928   arg1 = (Dali::Toolkit::TableView *)jarg1;
82929   arg2 = (unsigned int)jarg2;
82930   {
82931     try {
82932       (arg1)->DeleteColumn(arg2);
82933     } catch (std::out_of_range& e) {
82934       {
82935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82936       };
82937     } catch (std::exception& e) {
82938       {
82939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82940       };
82941     } catch (Dali::DaliException e) {
82942       {
82943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82944       };
82945     } catch (...) {
82946       {
82947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82948       };
82949     }
82950   }
82951
82952 }
82953
82954
82955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82956   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82957   unsigned int arg2 ;
82958   std::vector< Dali::Actor > *arg3 = 0 ;
82959
82960   arg1 = (Dali::Toolkit::TableView *)jarg1;
82961   arg2 = (unsigned int)jarg2;
82962   arg3 = (std::vector< Dali::Actor > *)jarg3;
82963   if (!arg3) {
82964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82965     return ;
82966   }
82967   {
82968     try {
82969       (arg1)->DeleteColumn(arg2,*arg3);
82970     } catch (std::out_of_range& e) {
82971       {
82972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82973       };
82974     } catch (std::exception& e) {
82975       {
82976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82977       };
82978     } catch (Dali::DaliException e) {
82979       {
82980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82981       };
82982     } catch (...) {
82983       {
82984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82985       };
82986     }
82987   }
82988
82989 }
82990
82991
82992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82993   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82994   unsigned int arg2 ;
82995   unsigned int arg3 ;
82996
82997   arg1 = (Dali::Toolkit::TableView *)jarg1;
82998   arg2 = (unsigned int)jarg2;
82999   arg3 = (unsigned int)jarg3;
83000   {
83001     try {
83002       (arg1)->Resize(arg2,arg3);
83003     } catch (std::out_of_range& e) {
83004       {
83005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83006       };
83007     } catch (std::exception& e) {
83008       {
83009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83010       };
83011     } catch (Dali::DaliException e) {
83012       {
83013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83014       };
83015     } catch (...) {
83016       {
83017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83018       };
83019     }
83020   }
83021
83022 }
83023
83024
83025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83026   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83027   unsigned int arg2 ;
83028   unsigned int arg3 ;
83029   std::vector< Dali::Actor > *arg4 = 0 ;
83030
83031   arg1 = (Dali::Toolkit::TableView *)jarg1;
83032   arg2 = (unsigned int)jarg2;
83033   arg3 = (unsigned int)jarg3;
83034   arg4 = (std::vector< Dali::Actor > *)jarg4;
83035   if (!arg4) {
83036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83037     return ;
83038   }
83039   {
83040     try {
83041       (arg1)->Resize(arg2,arg3,*arg4);
83042     } catch (std::out_of_range& e) {
83043       {
83044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83045       };
83046     } catch (std::exception& e) {
83047       {
83048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83049       };
83050     } catch (Dali::DaliException e) {
83051       {
83052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83053       };
83054     } catch (...) {
83055       {
83056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83057       };
83058     }
83059   }
83060
83061 }
83062
83063
83064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83065   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83066   Dali::Size arg2 ;
83067   Dali::Size *argp2 ;
83068
83069   arg1 = (Dali::Toolkit::TableView *)jarg1;
83070   argp2 = (Dali::Size *)jarg2;
83071   if (!argp2) {
83072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83073     return ;
83074   }
83075   arg2 = *argp2;
83076   {
83077     try {
83078       (arg1)->SetCellPadding(arg2);
83079     } catch (std::out_of_range& e) {
83080       {
83081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83082       };
83083     } catch (std::exception& e) {
83084       {
83085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83086       };
83087     } catch (Dali::DaliException e) {
83088       {
83089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83090       };
83091     } catch (...) {
83092       {
83093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83094       };
83095     }
83096   }
83097
83098 }
83099
83100
83101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83102   void * jresult ;
83103   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83104   Dali::Size result;
83105
83106   arg1 = (Dali::Toolkit::TableView *)jarg1;
83107   {
83108     try {
83109       result = (arg1)->GetCellPadding();
83110     } catch (std::out_of_range& e) {
83111       {
83112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83113       };
83114     } catch (std::exception& e) {
83115       {
83116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83117       };
83118     } catch (Dali::DaliException e) {
83119       {
83120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83121       };
83122     } catch (...) {
83123       {
83124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83125       };
83126     }
83127   }
83128
83129   jresult = new Dali::Size((const Dali::Size &)result);
83130   return jresult;
83131 }
83132
83133
83134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83135   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83136   unsigned int arg2 ;
83137
83138   arg1 = (Dali::Toolkit::TableView *)jarg1;
83139   arg2 = (unsigned int)jarg2;
83140   {
83141     try {
83142       (arg1)->SetFitHeight(arg2);
83143     } catch (std::out_of_range& e) {
83144       {
83145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83146       };
83147     } catch (std::exception& e) {
83148       {
83149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83150       };
83151     } catch (Dali::DaliException e) {
83152       {
83153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83154       };
83155     } catch (...) {
83156       {
83157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83158       };
83159     }
83160   }
83161
83162 }
83163
83164
83165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83166   unsigned int jresult ;
83167   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83168   unsigned int arg2 ;
83169   bool result;
83170
83171   arg1 = (Dali::Toolkit::TableView *)jarg1;
83172   arg2 = (unsigned int)jarg2;
83173   {
83174     try {
83175       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83176     } catch (std::out_of_range& e) {
83177       {
83178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83179       };
83180     } catch (std::exception& e) {
83181       {
83182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83183       };
83184     } catch (Dali::DaliException e) {
83185       {
83186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83187       };
83188     } catch (...) {
83189       {
83190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83191       };
83192     }
83193   }
83194
83195   jresult = result;
83196   return jresult;
83197 }
83198
83199
83200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83201   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83202   unsigned int arg2 ;
83203
83204   arg1 = (Dali::Toolkit::TableView *)jarg1;
83205   arg2 = (unsigned int)jarg2;
83206   {
83207     try {
83208       (arg1)->SetFitWidth(arg2);
83209     } catch (std::out_of_range& e) {
83210       {
83211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83212       };
83213     } catch (std::exception& e) {
83214       {
83215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83216       };
83217     } catch (Dali::DaliException e) {
83218       {
83219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83220       };
83221     } catch (...) {
83222       {
83223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83224       };
83225     }
83226   }
83227
83228 }
83229
83230
83231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83232   unsigned int jresult ;
83233   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83234   unsigned int arg2 ;
83235   bool result;
83236
83237   arg1 = (Dali::Toolkit::TableView *)jarg1;
83238   arg2 = (unsigned int)jarg2;
83239   {
83240     try {
83241       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83242     } catch (std::out_of_range& e) {
83243       {
83244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83245       };
83246     } catch (std::exception& e) {
83247       {
83248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83249       };
83250     } catch (Dali::DaliException e) {
83251       {
83252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83253       };
83254     } catch (...) {
83255       {
83256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83257       };
83258     }
83259   }
83260
83261   jresult = result;
83262   return jresult;
83263 }
83264
83265
83266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83267   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83268   unsigned int arg2 ;
83269   float arg3 ;
83270
83271   arg1 = (Dali::Toolkit::TableView *)jarg1;
83272   arg2 = (unsigned int)jarg2;
83273   arg3 = (float)jarg3;
83274   {
83275     try {
83276       (arg1)->SetFixedHeight(arg2,arg3);
83277     } catch (std::out_of_range& e) {
83278       {
83279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83280       };
83281     } catch (std::exception& e) {
83282       {
83283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83284       };
83285     } catch (Dali::DaliException e) {
83286       {
83287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83288       };
83289     } catch (...) {
83290       {
83291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83292       };
83293     }
83294   }
83295
83296 }
83297
83298
83299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83300   float jresult ;
83301   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83302   unsigned int arg2 ;
83303   float result;
83304
83305   arg1 = (Dali::Toolkit::TableView *)jarg1;
83306   arg2 = (unsigned int)jarg2;
83307   {
83308     try {
83309       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83310     } catch (std::out_of_range& e) {
83311       {
83312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83313       };
83314     } catch (std::exception& e) {
83315       {
83316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83317       };
83318     } catch (Dali::DaliException e) {
83319       {
83320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83321       };
83322     } catch (...) {
83323       {
83324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83325       };
83326     }
83327   }
83328
83329   jresult = result;
83330   return jresult;
83331 }
83332
83333
83334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83335   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83336   unsigned int arg2 ;
83337   float arg3 ;
83338
83339   arg1 = (Dali::Toolkit::TableView *)jarg1;
83340   arg2 = (unsigned int)jarg2;
83341   arg3 = (float)jarg3;
83342   {
83343     try {
83344       (arg1)->SetRelativeHeight(arg2,arg3);
83345     } catch (std::out_of_range& e) {
83346       {
83347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83348       };
83349     } catch (std::exception& e) {
83350       {
83351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83352       };
83353     } catch (Dali::DaliException e) {
83354       {
83355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83356       };
83357     } catch (...) {
83358       {
83359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83360       };
83361     }
83362   }
83363
83364 }
83365
83366
83367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83368   float jresult ;
83369   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83370   unsigned int arg2 ;
83371   float result;
83372
83373   arg1 = (Dali::Toolkit::TableView *)jarg1;
83374   arg2 = (unsigned int)jarg2;
83375   {
83376     try {
83377       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83378     } catch (std::out_of_range& e) {
83379       {
83380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83381       };
83382     } catch (std::exception& e) {
83383       {
83384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83385       };
83386     } catch (Dali::DaliException e) {
83387       {
83388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83389       };
83390     } catch (...) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83393       };
83394     }
83395   }
83396
83397   jresult = result;
83398   return jresult;
83399 }
83400
83401
83402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83403   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83404   unsigned int arg2 ;
83405   float arg3 ;
83406
83407   arg1 = (Dali::Toolkit::TableView *)jarg1;
83408   arg2 = (unsigned int)jarg2;
83409   arg3 = (float)jarg3;
83410   {
83411     try {
83412       (arg1)->SetFixedWidth(arg2,arg3);
83413     } catch (std::out_of_range& e) {
83414       {
83415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83416       };
83417     } catch (std::exception& e) {
83418       {
83419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83420       };
83421     } catch (Dali::DaliException e) {
83422       {
83423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83424       };
83425     } catch (...) {
83426       {
83427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83428       };
83429     }
83430   }
83431
83432 }
83433
83434
83435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83436   float jresult ;
83437   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83438   unsigned int arg2 ;
83439   float result;
83440
83441   arg1 = (Dali::Toolkit::TableView *)jarg1;
83442   arg2 = (unsigned int)jarg2;
83443   {
83444     try {
83445       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83446     } catch (std::out_of_range& e) {
83447       {
83448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83449       };
83450     } catch (std::exception& e) {
83451       {
83452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83453       };
83454     } catch (Dali::DaliException e) {
83455       {
83456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83457       };
83458     } catch (...) {
83459       {
83460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83461       };
83462     }
83463   }
83464
83465   jresult = result;
83466   return jresult;
83467 }
83468
83469
83470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83471   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83472   unsigned int arg2 ;
83473   float arg3 ;
83474
83475   arg1 = (Dali::Toolkit::TableView *)jarg1;
83476   arg2 = (unsigned int)jarg2;
83477   arg3 = (float)jarg3;
83478   {
83479     try {
83480       (arg1)->SetRelativeWidth(arg2,arg3);
83481     } catch (std::out_of_range& e) {
83482       {
83483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83484       };
83485     } catch (std::exception& e) {
83486       {
83487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83488       };
83489     } catch (Dali::DaliException e) {
83490       {
83491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83492       };
83493     } catch (...) {
83494       {
83495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83496       };
83497     }
83498   }
83499
83500 }
83501
83502
83503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83504   float jresult ;
83505   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83506   unsigned int arg2 ;
83507   float result;
83508
83509   arg1 = (Dali::Toolkit::TableView *)jarg1;
83510   arg2 = (unsigned int)jarg2;
83511   {
83512     try {
83513       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83514     } catch (std::out_of_range& e) {
83515       {
83516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83517       };
83518     } catch (std::exception& e) {
83519       {
83520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83521       };
83522     } catch (Dali::DaliException e) {
83523       {
83524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83525       };
83526     } catch (...) {
83527       {
83528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83529       };
83530     }
83531   }
83532
83533   jresult = result;
83534   return jresult;
83535 }
83536
83537
83538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83539   unsigned int jresult ;
83540   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83541   unsigned int result;
83542
83543   arg1 = (Dali::Toolkit::TableView *)jarg1;
83544   {
83545     try {
83546       result = (unsigned int)(arg1)->GetRows();
83547     } catch (std::out_of_range& e) {
83548       {
83549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83550       };
83551     } catch (std::exception& e) {
83552       {
83553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83554       };
83555     } catch (Dali::DaliException e) {
83556       {
83557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83558       };
83559     } catch (...) {
83560       {
83561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83562       };
83563     }
83564   }
83565
83566   jresult = result;
83567   return jresult;
83568 }
83569
83570
83571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83572   unsigned int jresult ;
83573   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83574   unsigned int result;
83575
83576   arg1 = (Dali::Toolkit::TableView *)jarg1;
83577   {
83578     try {
83579       result = (unsigned int)(arg1)->GetColumns();
83580     } catch (std::out_of_range& e) {
83581       {
83582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83583       };
83584     } catch (std::exception& e) {
83585       {
83586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83587       };
83588     } catch (Dali::DaliException e) {
83589       {
83590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83591       };
83592     } catch (...) {
83593       {
83594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83595       };
83596     }
83597   }
83598
83599   jresult = result;
83600   return jresult;
83601 }
83602
83603
83604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83605   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83606   Dali::Toolkit::TableView::CellPosition arg2 ;
83607   Dali::HorizontalAlignment::Type arg3 ;
83608   Dali::VerticalAlignment::Type arg4 ;
83609   Dali::Toolkit::TableView::CellPosition *argp2 ;
83610
83611   arg1 = (Dali::Toolkit::TableView *)jarg1;
83612   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83613   if (!argp2) {
83614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83615     return ;
83616   }
83617   arg2 = *argp2;
83618   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83619   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83620   {
83621     try {
83622       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83623     } catch (std::out_of_range& e) {
83624       {
83625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83626       };
83627     } catch (std::exception& e) {
83628       {
83629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83630       };
83631     } catch (Dali::DaliException e) {
83632       {
83633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83634       };
83635     } catch (...) {
83636       {
83637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83638       };
83639     }
83640   }
83641
83642 }
83643
83644
83645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83646   unsigned int jresult ;
83647   unsigned int result;
83648
83649   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83650   jresult = result;
83651   return jresult;
83652 }
83653
83654
83655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83656   int jresult ;
83657   int result;
83658
83659   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83660   jresult = (int)result;
83661   return jresult;
83662 }
83663
83664
83665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83666   int jresult ;
83667   int result;
83668
83669   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83670   jresult = (int)result;
83671   return jresult;
83672 }
83673
83674
83675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83676   int jresult ;
83677   int result;
83678
83679   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83680   jresult = (int)result;
83681   return jresult;
83682 }
83683
83684
83685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83686   int jresult ;
83687   int result;
83688
83689   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83690   jresult = (int)result;
83691   return jresult;
83692 }
83693
83694
83695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83696   int jresult ;
83697   int result;
83698
83699   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83700   jresult = (int)result;
83701   return jresult;
83702 }
83703
83704
83705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83706   int jresult ;
83707   int result;
83708
83709   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83710   jresult = (int)result;
83711   return jresult;
83712 }
83713
83714
83715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83716   int jresult ;
83717   int result;
83718
83719   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83720   jresult = (int)result;
83721   return jresult;
83722 }
83723
83724
83725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83726   int jresult ;
83727   int result;
83728
83729   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83730   jresult = (int)result;
83731   return jresult;
83732 }
83733
83734
83735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83736   int jresult ;
83737   int result;
83738
83739   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83740   jresult = (int)result;
83741   return jresult;
83742 }
83743
83744
83745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83746   int jresult ;
83747   int result;
83748
83749   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83750   jresult = (int)result;
83751   return jresult;
83752 }
83753
83754
83755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83756   int jresult ;
83757   int result;
83758
83759   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83760   jresult = (int)result;
83761   return jresult;
83762 }
83763
83764
83765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83766   int jresult ;
83767   int result;
83768
83769   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83770   jresult = (int)result;
83771   return jresult;
83772 }
83773
83774
83775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83776   int jresult ;
83777   int result;
83778
83779   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83780   jresult = (int)result;
83781   return jresult;
83782 }
83783
83784
83785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83786   int jresult ;
83787   int result;
83788
83789   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83790   jresult = (int)result;
83791   return jresult;
83792 }
83793
83794
83795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83796   int jresult ;
83797   int result;
83798
83799   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83800   jresult = (int)result;
83801   return jresult;
83802 }
83803
83804
83805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83806   int jresult ;
83807   int result;
83808
83809   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83810   jresult = (int)result;
83811   return jresult;
83812 }
83813
83814
83815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83816   int jresult ;
83817   int result;
83818
83819   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83820   jresult = (int)result;
83821   return jresult;
83822 }
83823
83824
83825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83826   int jresult ;
83827   int result;
83828
83829   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83830   jresult = (int)result;
83831   return jresult;
83832 }
83833
83834
83835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
83836   int jresult ;
83837   int result;
83838
83839   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
83840   jresult = (int)result;
83841   return jresult;
83842 }
83843
83844
83845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
83846   void * jresult ;
83847   Dali::Toolkit::TextLabel::Property *result = 0 ;
83848
83849   {
83850     try {
83851       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
83852     } catch (std::out_of_range& e) {
83853       {
83854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83855       };
83856     } catch (std::exception& e) {
83857       {
83858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83859       };
83860     } catch (Dali::DaliException e) {
83861       {
83862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83863       };
83864     } catch (...) {
83865       {
83866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83867       };
83868     }
83869   }
83870
83871   jresult = (void *)result;
83872   return jresult;
83873 }
83874
83875
83876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
83877   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
83878
83879   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
83880   {
83881     try {
83882       delete arg1;
83883     } catch (std::out_of_range& e) {
83884       {
83885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83886       };
83887     } catch (std::exception& e) {
83888       {
83889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83890       };
83891     } catch (Dali::DaliException e) {
83892       {
83893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83894       };
83895     } catch (...) {
83896       {
83897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83898       };
83899     }
83900   }
83901
83902 }
83903
83904
83905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83906   void * jresult ;
83907   Dali::Toolkit::TextLabel result;
83908
83909   {
83910     try {
83911       result = Dali::Toolkit::TextLabel::New();
83912     } catch (std::out_of_range& e) {
83913       {
83914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (std::exception& e) {
83917       {
83918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83919       };
83920     } catch (Dali::DaliException e) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83923       };
83924     } catch (...) {
83925       {
83926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83927       };
83928     }
83929   }
83930
83931   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83932   return jresult;
83933 }
83934
83935
83936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83937   void * jresult ;
83938   std::string *arg1 = 0 ;
83939   Dali::Toolkit::TextLabel result;
83940
83941   if (!jarg1) {
83942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83943     return 0;
83944   }
83945   std::string arg1_str(jarg1);
83946   arg1 = &arg1_str;
83947   {
83948     try {
83949       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83950     } catch (std::out_of_range& e) {
83951       {
83952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83953       };
83954     } catch (std::exception& e) {
83955       {
83956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83957       };
83958     } catch (Dali::DaliException e) {
83959       {
83960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83961       };
83962     } catch (...) {
83963       {
83964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83965       };
83966     }
83967   }
83968
83969   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83970
83971   //argout typemap for const std::string&
83972
83973   return jresult;
83974 }
83975
83976
83977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83978   void * jresult ;
83979   Dali::Toolkit::TextLabel *result = 0 ;
83980
83981   {
83982     try {
83983       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83984     } catch (std::out_of_range& e) {
83985       {
83986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83987       };
83988     } catch (std::exception& e) {
83989       {
83990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83991       };
83992     } catch (Dali::DaliException e) {
83993       {
83994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83995       };
83996     } catch (...) {
83997       {
83998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83999       };
84000     }
84001   }
84002
84003   jresult = (void *)result;
84004   return jresult;
84005 }
84006
84007
84008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84009   void * jresult ;
84010   Dali::Toolkit::TextLabel *arg1 = 0 ;
84011   Dali::Toolkit::TextLabel *result = 0 ;
84012
84013   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84014   if (!arg1) {
84015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84016     return 0;
84017   }
84018   {
84019     try {
84020       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84021     } catch (std::out_of_range& e) {
84022       {
84023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84024       };
84025     } catch (std::exception& e) {
84026       {
84027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84028       };
84029     } catch (Dali::DaliException e) {
84030       {
84031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84032       };
84033     } catch (...) {
84034       {
84035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84036       };
84037     }
84038   }
84039
84040   jresult = (void *)result;
84041   return jresult;
84042 }
84043
84044
84045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84046   void * jresult ;
84047   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84048   Dali::Toolkit::TextLabel *arg2 = 0 ;
84049   Dali::Toolkit::TextLabel *result = 0 ;
84050
84051   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84052   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84053   if (!arg2) {
84054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84055     return 0;
84056   }
84057   {
84058     try {
84059       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84060     } catch (std::out_of_range& e) {
84061       {
84062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84063       };
84064     } catch (std::exception& e) {
84065       {
84066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84067       };
84068     } catch (Dali::DaliException e) {
84069       {
84070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84071       };
84072     } catch (...) {
84073       {
84074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84075       };
84076     }
84077   }
84078
84079   jresult = (void *)result;
84080   return jresult;
84081 }
84082
84083
84084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84085   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84086
84087   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84088   {
84089     try {
84090       delete arg1;
84091     } catch (std::out_of_range& e) {
84092       {
84093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84094       };
84095     } catch (std::exception& e) {
84096       {
84097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84098       };
84099     } catch (Dali::DaliException e) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84102       };
84103     } catch (...) {
84104       {
84105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84106       };
84107     }
84108   }
84109
84110 }
84111
84112
84113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84114   void * jresult ;
84115   Dali::BaseHandle arg1 ;
84116   Dali::BaseHandle *argp1 ;
84117   Dali::Toolkit::TextLabel result;
84118
84119   argp1 = (Dali::BaseHandle *)jarg1;
84120   if (!argp1) {
84121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84122     return 0;
84123   }
84124   arg1 = *argp1;
84125   {
84126     try {
84127       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84128     } catch (std::out_of_range& e) {
84129       {
84130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84131       };
84132     } catch (std::exception& e) {
84133       {
84134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84135       };
84136     } catch (Dali::DaliException e) {
84137       {
84138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84139       };
84140     } catch (...) {
84141       {
84142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84143       };
84144     }
84145   }
84146
84147   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84148   return jresult;
84149 }
84150
84151
84152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84153   void * jresult ;
84154   Dali::Toolkit::AccessibilityManager *result = 0 ;
84155
84156   {
84157     try {
84158       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84159     } catch (std::out_of_range& e) {
84160       {
84161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84162       };
84163     } catch (std::exception& e) {
84164       {
84165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84166       };
84167     } catch (Dali::DaliException e) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84170       };
84171     } catch (...) {
84172       {
84173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84174       };
84175     }
84176   }
84177
84178   jresult = (void *)result;
84179   return jresult;
84180 }
84181
84182
84183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84184   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84185
84186   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84187   {
84188     try {
84189       delete arg1;
84190     } catch (std::out_of_range& e) {
84191       {
84192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84193       };
84194     } catch (std::exception& e) {
84195       {
84196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84197       };
84198     } catch (Dali::DaliException e) {
84199       {
84200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84201       };
84202     } catch (...) {
84203       {
84204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84205       };
84206     }
84207   }
84208
84209 }
84210
84211
84212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84213   void * jresult ;
84214   Dali::Toolkit::AccessibilityManager result;
84215
84216   {
84217     try {
84218       result = Dali::Toolkit::AccessibilityManager::Get();
84219     } catch (std::out_of_range& e) {
84220       {
84221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84222       };
84223     } catch (std::exception& e) {
84224       {
84225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84226       };
84227     } catch (Dali::DaliException e) {
84228       {
84229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84230       };
84231     } catch (...) {
84232       {
84233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84234       };
84235     }
84236   }
84237
84238   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84239   return jresult;
84240 }
84241
84242
84243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84245   Dali::Actor arg2 ;
84246   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84247   std::string *arg4 = 0 ;
84248   Dali::Actor *argp2 ;
84249
84250   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84251   argp2 = (Dali::Actor *)jarg2;
84252   if (!argp2) {
84253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84254     return ;
84255   }
84256   arg2 = *argp2;
84257   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84258   if (!jarg4) {
84259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84260     return ;
84261   }
84262   std::string arg4_str(jarg4);
84263   arg4 = &arg4_str;
84264   {
84265     try {
84266       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84267     } catch (std::out_of_range& e) {
84268       {
84269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84270       };
84271     } catch (std::exception& e) {
84272       {
84273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84274       };
84275     } catch (Dali::DaliException e) {
84276       {
84277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84278       };
84279     } catch (...) {
84280       {
84281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84282       };
84283     }
84284   }
84285
84286
84287   //argout typemap for const std::string&
84288
84289 }
84290
84291
84292 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84293   char * jresult ;
84294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84295   Dali::Actor arg2 ;
84296   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84297   Dali::Actor *argp2 ;
84298   std::string result;
84299
84300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84301   argp2 = (Dali::Actor *)jarg2;
84302   if (!argp2) {
84303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84304     return 0;
84305   }
84306   arg2 = *argp2;
84307   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84308   {
84309     try {
84310       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84311     } catch (std::out_of_range& e) {
84312       {
84313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84314       };
84315     } catch (std::exception& e) {
84316       {
84317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84318       };
84319     } catch (Dali::DaliException e) {
84320       {
84321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84322       };
84323     } catch (...) {
84324       {
84325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84326       };
84327     }
84328   }
84329
84330   jresult = SWIG_csharp_string_callback((&result)->c_str());
84331   return jresult;
84332 }
84333
84334
84335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84336   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84337   Dali::Actor arg2 ;
84338   unsigned int arg3 ;
84339   Dali::Actor *argp2 ;
84340
84341   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84342   argp2 = (Dali::Actor *)jarg2;
84343   if (!argp2) {
84344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84345     return ;
84346   }
84347   arg2 = *argp2;
84348   arg3 = (unsigned int)jarg3;
84349   {
84350     try {
84351       (arg1)->SetFocusOrder(arg2,arg3);
84352     } catch (std::out_of_range& e) {
84353       {
84354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84355       };
84356     } catch (std::exception& e) {
84357       {
84358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84359       };
84360     } catch (Dali::DaliException e) {
84361       {
84362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84363       };
84364     } catch (...) {
84365       {
84366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84367       };
84368     }
84369   }
84370
84371 }
84372
84373
84374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84375   unsigned int jresult ;
84376   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84377   Dali::Actor arg2 ;
84378   Dali::Actor *argp2 ;
84379   unsigned int result;
84380
84381   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84382   argp2 = (Dali::Actor *)jarg2;
84383   if (!argp2) {
84384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84385     return 0;
84386   }
84387   arg2 = *argp2;
84388   {
84389     try {
84390       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84391     } catch (std::out_of_range& e) {
84392       {
84393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84394       };
84395     } catch (std::exception& e) {
84396       {
84397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84398       };
84399     } catch (Dali::DaliException e) {
84400       {
84401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84402       };
84403     } catch (...) {
84404       {
84405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84406       };
84407     }
84408   }
84409
84410   jresult = result;
84411   return jresult;
84412 }
84413
84414
84415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84416   unsigned int jresult ;
84417   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84418   unsigned int result;
84419
84420   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84421   {
84422     try {
84423       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84424     } catch (std::out_of_range& e) {
84425       {
84426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84427       };
84428     } catch (std::exception& e) {
84429       {
84430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84431       };
84432     } catch (Dali::DaliException e) {
84433       {
84434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84435       };
84436     } catch (...) {
84437       {
84438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84439       };
84440     }
84441   }
84442
84443   jresult = result;
84444   return jresult;
84445 }
84446
84447
84448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84449   void * jresult ;
84450   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84451   unsigned int arg2 ;
84452   Dali::Actor result;
84453
84454   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84455   arg2 = (unsigned int)jarg2;
84456   {
84457     try {
84458       result = (arg1)->GetActorByFocusOrder(arg2);
84459     } catch (std::out_of_range& e) {
84460       {
84461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84462       };
84463     } catch (std::exception& e) {
84464       {
84465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84466       };
84467     } catch (Dali::DaliException e) {
84468       {
84469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84470       };
84471     } catch (...) {
84472       {
84473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84474       };
84475     }
84476   }
84477
84478   jresult = new Dali::Actor((const Dali::Actor &)result);
84479   return jresult;
84480 }
84481
84482
84483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84484   unsigned int jresult ;
84485   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84486   Dali::Actor arg2 ;
84487   Dali::Actor *argp2 ;
84488   bool result;
84489
84490   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84491   argp2 = (Dali::Actor *)jarg2;
84492   if (!argp2) {
84493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84494     return 0;
84495   }
84496   arg2 = *argp2;
84497   {
84498     try {
84499       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84500     } catch (std::out_of_range& e) {
84501       {
84502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84503       };
84504     } catch (std::exception& e) {
84505       {
84506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84507       };
84508     } catch (Dali::DaliException e) {
84509       {
84510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84511       };
84512     } catch (...) {
84513       {
84514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84515       };
84516     }
84517   }
84518
84519   jresult = result;
84520   return jresult;
84521 }
84522
84523
84524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84525   void * jresult ;
84526   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84527   Dali::Actor result;
84528
84529   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84530   {
84531     try {
84532       result = (arg1)->GetCurrentFocusActor();
84533     } catch (std::out_of_range& e) {
84534       {
84535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84536       };
84537     } catch (std::exception& e) {
84538       {
84539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84540       };
84541     } catch (Dali::DaliException e) {
84542       {
84543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84544       };
84545     } catch (...) {
84546       {
84547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84548       };
84549     }
84550   }
84551
84552   jresult = new Dali::Actor((const Dali::Actor &)result);
84553   return jresult;
84554 }
84555
84556
84557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84558   void * jresult ;
84559   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84560   Dali::Actor result;
84561
84562   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84563   {
84564     try {
84565       result = (arg1)->GetCurrentFocusGroup();
84566     } catch (std::out_of_range& e) {
84567       {
84568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84569       };
84570     } catch (std::exception& e) {
84571       {
84572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84573       };
84574     } catch (Dali::DaliException e) {
84575       {
84576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84577       };
84578     } catch (...) {
84579       {
84580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84581       };
84582     }
84583   }
84584
84585   jresult = new Dali::Actor((const Dali::Actor &)result);
84586   return jresult;
84587 }
84588
84589
84590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84591   unsigned int jresult ;
84592   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84593   unsigned int result;
84594
84595   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84596   {
84597     try {
84598       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84599     } catch (std::out_of_range& e) {
84600       {
84601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84602       };
84603     } catch (std::exception& e) {
84604       {
84605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84606       };
84607     } catch (Dali::DaliException e) {
84608       {
84609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84610       };
84611     } catch (...) {
84612       {
84613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84614       };
84615     }
84616   }
84617
84618   jresult = result;
84619   return jresult;
84620 }
84621
84622
84623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84624   unsigned int jresult ;
84625   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84626   bool result;
84627
84628   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84629   {
84630     try {
84631       result = (bool)(arg1)->MoveFocusForward();
84632     } catch (std::out_of_range& e) {
84633       {
84634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84635       };
84636     } catch (std::exception& e) {
84637       {
84638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84639       };
84640     } catch (Dali::DaliException e) {
84641       {
84642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84643       };
84644     } catch (...) {
84645       {
84646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84647       };
84648     }
84649   }
84650
84651   jresult = result;
84652   return jresult;
84653 }
84654
84655
84656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84657   unsigned int jresult ;
84658   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84659   bool result;
84660
84661   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84662   {
84663     try {
84664       result = (bool)(arg1)->MoveFocusBackward();
84665     } catch (std::out_of_range& e) {
84666       {
84667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84668       };
84669     } catch (std::exception& e) {
84670       {
84671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84672       };
84673     } catch (Dali::DaliException e) {
84674       {
84675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84676       };
84677     } catch (...) {
84678       {
84679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84680       };
84681     }
84682   }
84683
84684   jresult = result;
84685   return jresult;
84686 }
84687
84688
84689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84690   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84691
84692   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84693   {
84694     try {
84695       (arg1)->ClearFocus();
84696     } catch (std::out_of_range& e) {
84697       {
84698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84699       };
84700     } catch (std::exception& e) {
84701       {
84702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84703       };
84704     } catch (Dali::DaliException e) {
84705       {
84706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84707       };
84708     } catch (...) {
84709       {
84710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84711       };
84712     }
84713   }
84714
84715 }
84716
84717
84718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84719   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84720
84721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84722   {
84723     try {
84724       (arg1)->Reset();
84725     } catch (std::out_of_range& e) {
84726       {
84727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84728       };
84729     } catch (std::exception& e) {
84730       {
84731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84732       };
84733     } catch (Dali::DaliException e) {
84734       {
84735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84736       };
84737     } catch (...) {
84738       {
84739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84740       };
84741     }
84742   }
84743
84744 }
84745
84746
84747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84748   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84749   Dali::Actor arg2 ;
84750   bool arg3 ;
84751   Dali::Actor *argp2 ;
84752
84753   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84754   argp2 = (Dali::Actor *)jarg2;
84755   if (!argp2) {
84756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84757     return ;
84758   }
84759   arg2 = *argp2;
84760   arg3 = jarg3 ? true : false;
84761   {
84762     try {
84763       (arg1)->SetFocusGroup(arg2,arg3);
84764     } catch (std::out_of_range& e) {
84765       {
84766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84767       };
84768     } catch (std::exception& e) {
84769       {
84770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84771       };
84772     } catch (Dali::DaliException e) {
84773       {
84774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84775       };
84776     } catch (...) {
84777       {
84778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84779       };
84780     }
84781   }
84782
84783 }
84784
84785
84786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84787   unsigned int jresult ;
84788   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84789   Dali::Actor arg2 ;
84790   Dali::Actor *argp2 ;
84791   bool result;
84792
84793   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84794   argp2 = (Dali::Actor *)jarg2;
84795   if (!argp2) {
84796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84797     return 0;
84798   }
84799   arg2 = *argp2;
84800   {
84801     try {
84802       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84803     } catch (std::out_of_range& e) {
84804       {
84805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84806       };
84807     } catch (std::exception& e) {
84808       {
84809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84810       };
84811     } catch (Dali::DaliException e) {
84812       {
84813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84814       };
84815     } catch (...) {
84816       {
84817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84818       };
84819     }
84820   }
84821
84822   jresult = result;
84823   return jresult;
84824 }
84825
84826
84827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84828   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84829   bool arg2 ;
84830
84831   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84832   arg2 = jarg2 ? true : false;
84833   {
84834     try {
84835       (arg1)->SetGroupMode(arg2);
84836     } catch (std::out_of_range& e) {
84837       {
84838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84839       };
84840     } catch (std::exception& e) {
84841       {
84842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84843       };
84844     } catch (Dali::DaliException e) {
84845       {
84846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84847       };
84848     } catch (...) {
84849       {
84850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84851       };
84852     }
84853   }
84854
84855 }
84856
84857
84858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
84859   unsigned int jresult ;
84860   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84861   bool result;
84862
84863   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84864   {
84865     try {
84866       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
84867     } catch (std::out_of_range& e) {
84868       {
84869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84870       };
84871     } catch (std::exception& e) {
84872       {
84873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84874       };
84875     } catch (Dali::DaliException e) {
84876       {
84877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84878       };
84879     } catch (...) {
84880       {
84881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84882       };
84883     }
84884   }
84885
84886   jresult = result;
84887   return jresult;
84888 }
84889
84890
84891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84892   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84893   bool arg2 ;
84894
84895   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84896   arg2 = jarg2 ? true : false;
84897   {
84898     try {
84899       (arg1)->SetWrapMode(arg2);
84900     } catch (std::out_of_range& e) {
84901       {
84902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84903       };
84904     } catch (std::exception& e) {
84905       {
84906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84907       };
84908     } catch (Dali::DaliException e) {
84909       {
84910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84911       };
84912     } catch (...) {
84913       {
84914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84915       };
84916     }
84917   }
84918
84919 }
84920
84921
84922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84923   unsigned int jresult ;
84924   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84925   bool result;
84926
84927   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84928   {
84929     try {
84930       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84931     } catch (std::out_of_range& e) {
84932       {
84933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84934       };
84935     } catch (std::exception& e) {
84936       {
84937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84938       };
84939     } catch (Dali::DaliException e) {
84940       {
84941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84942       };
84943     } catch (...) {
84944       {
84945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84946       };
84947     }
84948   }
84949
84950   jresult = result;
84951   return jresult;
84952 }
84953
84954
84955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84956   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84957   Dali::Actor arg2 ;
84958   Dali::Actor *argp2 ;
84959
84960   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84961   argp2 = (Dali::Actor *)jarg2;
84962   if (!argp2) {
84963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84964     return ;
84965   }
84966   arg2 = *argp2;
84967   {
84968     try {
84969       (arg1)->SetFocusIndicatorActor(arg2);
84970     } catch (std::out_of_range& e) {
84971       {
84972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84973       };
84974     } catch (std::exception& e) {
84975       {
84976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84977       };
84978     } catch (Dali::DaliException e) {
84979       {
84980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84981       };
84982     } catch (...) {
84983       {
84984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84985       };
84986     }
84987   }
84988
84989 }
84990
84991
84992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84993   void * jresult ;
84994   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84995   Dali::Actor result;
84996
84997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84998   {
84999     try {
85000       result = (arg1)->GetFocusIndicatorActor();
85001     } catch (std::out_of_range& e) {
85002       {
85003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85004       };
85005     } catch (std::exception& e) {
85006       {
85007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85008       };
85009     } catch (Dali::DaliException e) {
85010       {
85011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85012       };
85013     } catch (...) {
85014       {
85015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85016       };
85017     }
85018   }
85019
85020   jresult = new Dali::Actor((const Dali::Actor &)result);
85021   return jresult;
85022 }
85023
85024
85025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85026   void * jresult ;
85027   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85028   Dali::Actor arg2 ;
85029   Dali::Actor *argp2 ;
85030   Dali::Actor result;
85031
85032   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85033   argp2 = (Dali::Actor *)jarg2;
85034   if (!argp2) {
85035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85036     return 0;
85037   }
85038   arg2 = *argp2;
85039   {
85040     try {
85041       result = (arg1)->GetFocusGroup(arg2);
85042     } catch (std::out_of_range& e) {
85043       {
85044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85045       };
85046     } catch (std::exception& e) {
85047       {
85048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85049       };
85050     } catch (Dali::DaliException e) {
85051       {
85052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85053       };
85054     } catch (...) {
85055       {
85056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85057       };
85058     }
85059   }
85060
85061   jresult = new Dali::Actor((const Dali::Actor &)result);
85062   return jresult;
85063 }
85064
85065
85066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85067   void * jresult ;
85068   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85069   Dali::Vector2 result;
85070
85071   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85072   {
85073     try {
85074       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85075     } catch (std::out_of_range& e) {
85076       {
85077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85078       };
85079     } catch (std::exception& e) {
85080       {
85081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85082       };
85083     } catch (Dali::DaliException e) {
85084       {
85085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85086       };
85087     } catch (...) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85090       };
85091     }
85092   }
85093
85094   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85095   return jresult;
85096 }
85097
85098
85099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85100   void * jresult ;
85101   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85102   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85103
85104   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85105   {
85106     try {
85107       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85108     } catch (std::out_of_range& e) {
85109       {
85110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85111       };
85112     } catch (std::exception& e) {
85113       {
85114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85115       };
85116     } catch (Dali::DaliException e) {
85117       {
85118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85119       };
85120     } catch (...) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85123       };
85124     }
85125   }
85126
85127   jresult = (void *)result;
85128   return jresult;
85129 }
85130
85131
85132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85133   void * jresult ;
85134   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85135   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85136
85137   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85138   {
85139     try {
85140       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85141     } catch (std::out_of_range& e) {
85142       {
85143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85144       };
85145     } catch (std::exception& e) {
85146       {
85147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85148       };
85149     } catch (Dali::DaliException e) {
85150       {
85151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85152       };
85153     } catch (...) {
85154       {
85155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85156       };
85157     }
85158   }
85159
85160   jresult = (void *)result;
85161   return jresult;
85162 }
85163
85164
85165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85166   void * jresult ;
85167   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85168   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85169
85170   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85171   {
85172     try {
85173       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85174     } catch (std::out_of_range& e) {
85175       {
85176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85177       };
85178     } catch (std::exception& e) {
85179       {
85180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85181       };
85182     } catch (Dali::DaliException e) {
85183       {
85184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85185       };
85186     } catch (...) {
85187       {
85188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85189       };
85190     }
85191   }
85192
85193   jresult = (void *)result;
85194   return jresult;
85195 }
85196
85197
85198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85199   void * jresult ;
85200   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85201   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85202
85203   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85204   {
85205     try {
85206       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85207     } catch (std::out_of_range& e) {
85208       {
85209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85210       };
85211     } catch (std::exception& e) {
85212       {
85213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85214       };
85215     } catch (Dali::DaliException e) {
85216       {
85217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85218       };
85219     } catch (...) {
85220       {
85221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85222       };
85223     }
85224   }
85225
85226   jresult = (void *)result;
85227   return jresult;
85228 }
85229
85230
85231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85232   void * jresult ;
85233   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85234   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85235
85236   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85237   {
85238     try {
85239       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85240     } catch (std::out_of_range& e) {
85241       {
85242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85243       };
85244     } catch (std::exception& e) {
85245       {
85246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85247       };
85248     } catch (Dali::DaliException e) {
85249       {
85250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85251       };
85252     } catch (...) {
85253       {
85254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85255       };
85256     }
85257   }
85258
85259   jresult = (void *)result;
85260   return jresult;
85261 }
85262
85263
85264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85265   void * jresult ;
85266   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85267   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85268
85269   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85270   {
85271     try {
85272       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85273     } catch (std::out_of_range& e) {
85274       {
85275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85276       };
85277     } catch (std::exception& e) {
85278       {
85279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85280       };
85281     } catch (Dali::DaliException e) {
85282       {
85283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85284       };
85285     } catch (...) {
85286       {
85287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85288       };
85289     }
85290   }
85291
85292   jresult = (void *)result;
85293   return jresult;
85294 }
85295
85296
85297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85298   void * jresult ;
85299   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85300   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85301
85302   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85303   {
85304     try {
85305       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85306     } catch (std::out_of_range& e) {
85307       {
85308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85309       };
85310     } catch (std::exception& e) {
85311       {
85312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85313       };
85314     } catch (Dali::DaliException e) {
85315       {
85316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85317       };
85318     } catch (...) {
85319       {
85320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85321       };
85322     }
85323   }
85324
85325   jresult = (void *)result;
85326   return jresult;
85327 }
85328
85329
85330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85331   void * jresult ;
85332   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85333   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85334
85335   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85336   {
85337     try {
85338       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85339     } catch (std::out_of_range& e) {
85340       {
85341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85342       };
85343     } catch (std::exception& e) {
85344       {
85345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85346       };
85347     } catch (Dali::DaliException e) {
85348       {
85349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85350       };
85351     } catch (...) {
85352       {
85353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85354       };
85355     }
85356   }
85357
85358   jresult = (void *)result;
85359   return jresult;
85360 }
85361
85362
85363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85364   void * jresult ;
85365   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85366   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85367
85368   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85369   {
85370     try {
85371       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85372     } catch (std::out_of_range& e) {
85373       {
85374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85375       };
85376     } catch (std::exception& e) {
85377       {
85378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85379       };
85380     } catch (Dali::DaliException e) {
85381       {
85382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85383       };
85384     } catch (...) {
85385       {
85386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85387       };
85388     }
85389   }
85390
85391   jresult = (void *)result;
85392   return jresult;
85393 }
85394
85395
85396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85397   void * jresult ;
85398   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85399   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85400
85401   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85402   {
85403     try {
85404       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85405     } catch (std::out_of_range& e) {
85406       {
85407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85408       };
85409     } catch (std::exception& e) {
85410       {
85411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85412       };
85413     } catch (Dali::DaliException e) {
85414       {
85415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85416       };
85417     } catch (...) {
85418       {
85419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85420       };
85421     }
85422   }
85423
85424   jresult = (void *)result;
85425   return jresult;
85426 }
85427
85428
85429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85430   void * jresult ;
85431   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85432   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85433
85434   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85435   {
85436     try {
85437       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85438     } catch (std::out_of_range& e) {
85439       {
85440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85441       };
85442     } catch (std::exception& e) {
85443       {
85444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85445       };
85446     } catch (Dali::DaliException e) {
85447       {
85448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85449       };
85450     } catch (...) {
85451       {
85452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85453       };
85454     }
85455   }
85456
85457   jresult = (void *)result;
85458   return jresult;
85459 }
85460
85461
85462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85463   void * jresult ;
85464   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85465   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85466
85467   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85468   {
85469     try {
85470       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85471     } catch (std::out_of_range& e) {
85472       {
85473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85474       };
85475     } catch (std::exception& e) {
85476       {
85477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85478       };
85479     } catch (Dali::DaliException e) {
85480       {
85481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85482       };
85483     } catch (...) {
85484       {
85485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85486       };
85487     }
85488   }
85489
85490   jresult = (void *)result;
85491   return jresult;
85492 }
85493
85494
85495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85496   void * jresult ;
85497   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85498   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85499
85500   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85501   {
85502     try {
85503       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85504     } catch (std::out_of_range& e) {
85505       {
85506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85507       };
85508     } catch (std::exception& e) {
85509       {
85510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85511       };
85512     } catch (Dali::DaliException e) {
85513       {
85514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85515       };
85516     } catch (...) {
85517       {
85518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85519       };
85520     }
85521   }
85522
85523   jresult = (void *)result;
85524   return jresult;
85525 }
85526
85527
85528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85529   void * jresult ;
85530   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85531   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85532
85533   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85534   {
85535     try {
85536       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85537     } catch (std::out_of_range& e) {
85538       {
85539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85540       };
85541     } catch (std::exception& e) {
85542       {
85543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85544       };
85545     } catch (Dali::DaliException e) {
85546       {
85547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85548       };
85549     } catch (...) {
85550       {
85551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85552       };
85553     }
85554   }
85555
85556   jresult = (void *)result;
85557   return jresult;
85558 }
85559
85560
85561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85562   void * jresult ;
85563   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85564   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85565
85566   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85567   {
85568     try {
85569       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85570     } catch (std::out_of_range& e) {
85571       {
85572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85573       };
85574     } catch (std::exception& e) {
85575       {
85576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85577       };
85578     } catch (Dali::DaliException e) {
85579       {
85580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85581       };
85582     } catch (...) {
85583       {
85584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85585       };
85586     }
85587   }
85588
85589   jresult = (void *)result;
85590   return jresult;
85591 }
85592
85593
85594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85595   void * jresult ;
85596   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85597   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85598
85599   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85600   {
85601     try {
85602       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85603     } catch (std::out_of_range& e) {
85604       {
85605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85606       };
85607     } catch (std::exception& e) {
85608       {
85609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85610       };
85611     } catch (Dali::DaliException e) {
85612       {
85613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85614       };
85615     } catch (...) {
85616       {
85617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85618       };
85619     }
85620   }
85621
85622   jresult = (void *)result;
85623   return jresult;
85624 }
85625
85626
85627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85628   void * jresult ;
85629   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85630   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85631
85632   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85633   {
85634     try {
85635       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85636     } catch (std::out_of_range& e) {
85637       {
85638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85639       };
85640     } catch (std::exception& e) {
85641       {
85642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85643       };
85644     } catch (Dali::DaliException e) {
85645       {
85646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85647       };
85648     } catch (...) {
85649       {
85650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85651       };
85652     }
85653   }
85654
85655   jresult = (void *)result;
85656   return jresult;
85657 }
85658
85659
85660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85661   void * jresult ;
85662   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85663   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85664
85665   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85666   {
85667     try {
85668       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85669     } catch (std::out_of_range& e) {
85670       {
85671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85672       };
85673     } catch (std::exception& e) {
85674       {
85675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85676       };
85677     } catch (Dali::DaliException e) {
85678       {
85679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85680       };
85681     } catch (...) {
85682       {
85683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85684       };
85685     }
85686   }
85687
85688   jresult = (void *)result;
85689   return jresult;
85690 }
85691
85692
85693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85694   void * jresult ;
85695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85696   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85697
85698   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85699   {
85700     try {
85701       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85702     } catch (std::out_of_range& e) {
85703       {
85704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85705       };
85706     } catch (std::exception& e) {
85707       {
85708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85709       };
85710     } catch (Dali::DaliException e) {
85711       {
85712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85713       };
85714     } catch (...) {
85715       {
85716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85717       };
85718     }
85719   }
85720
85721   jresult = (void *)result;
85722   return jresult;
85723 }
85724
85725
85726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85727   void * jresult ;
85728   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85729   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85730
85731   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85732   {
85733     try {
85734       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85735     } catch (std::out_of_range& e) {
85736       {
85737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85738       };
85739     } catch (std::exception& e) {
85740       {
85741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85742       };
85743     } catch (Dali::DaliException e) {
85744       {
85745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85746       };
85747     } catch (...) {
85748       {
85749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85750       };
85751     }
85752   }
85753
85754   jresult = (void *)result;
85755   return jresult;
85756 }
85757
85758
85759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85760   void * jresult ;
85761   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85762   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85763
85764   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85765   {
85766     try {
85767       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85768     } catch (std::out_of_range& e) {
85769       {
85770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85771       };
85772     } catch (std::exception& e) {
85773       {
85774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85775       };
85776     } catch (Dali::DaliException e) {
85777       {
85778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85779       };
85780     } catch (...) {
85781       {
85782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85783       };
85784     }
85785   }
85786
85787   jresult = (void *)result;
85788   return jresult;
85789 }
85790
85791
85792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85793   void * jresult ;
85794   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85795   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85796
85797   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85798   {
85799     try {
85800       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85801     } catch (std::out_of_range& e) {
85802       {
85803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85804       };
85805     } catch (std::exception& e) {
85806       {
85807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85808       };
85809     } catch (Dali::DaliException e) {
85810       {
85811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85812       };
85813     } catch (...) {
85814       {
85815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85816       };
85817     }
85818   }
85819
85820   jresult = (void *)result;
85821   return jresult;
85822 }
85823
85824
85825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85826   void * jresult ;
85827   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85828   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85829
85830   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85831   {
85832     try {
85833       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
85834     } catch (std::out_of_range& e) {
85835       {
85836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85837       };
85838     } catch (std::exception& e) {
85839       {
85840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85841       };
85842     } catch (Dali::DaliException e) {
85843       {
85844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85845       };
85846     } catch (...) {
85847       {
85848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85849       };
85850     }
85851   }
85852
85853   jresult = (void *)result;
85854   return jresult;
85855 }
85856
85857
85858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
85859   void * jresult ;
85860   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85861   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85862
85863   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85864   {
85865     try {
85866       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
85867     } catch (std::out_of_range& e) {
85868       {
85869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85870       };
85871     } catch (std::exception& e) {
85872       {
85873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85874       };
85875     } catch (Dali::DaliException e) {
85876       {
85877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85878       };
85879     } catch (...) {
85880       {
85881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85882       };
85883     }
85884   }
85885
85886   jresult = (void *)result;
85887   return jresult;
85888 }
85889
85890
85891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85892   void * jresult ;
85893   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85894   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85895
85896   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85897   {
85898     try {
85899       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85900     } catch (std::out_of_range& e) {
85901       {
85902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85903       };
85904     } catch (std::exception& e) {
85905       {
85906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85907       };
85908     } catch (Dali::DaliException e) {
85909       {
85910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85911       };
85912     } catch (...) {
85913       {
85914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85915       };
85916     }
85917   }
85918
85919   jresult = (void *)result;
85920   return jresult;
85921 }
85922
85923
85924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85925   void * jresult ;
85926   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85927   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85928
85929   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85930   {
85931     try {
85932       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85933     } catch (std::out_of_range& e) {
85934       {
85935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85936       };
85937     } catch (std::exception& e) {
85938       {
85939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85940       };
85941     } catch (Dali::DaliException e) {
85942       {
85943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85944       };
85945     } catch (...) {
85946       {
85947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85948       };
85949     }
85950   }
85951
85952   jresult = (void *)result;
85953   return jresult;
85954 }
85955
85956
85957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85958   void * jresult ;
85959   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85960   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85961
85962   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85963   {
85964     try {
85965       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85966     } catch (std::out_of_range& e) {
85967       {
85968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85969       };
85970     } catch (std::exception& e) {
85971       {
85972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85973       };
85974     } catch (Dali::DaliException e) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85977       };
85978     } catch (...) {
85979       {
85980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85981       };
85982     }
85983   }
85984
85985   jresult = (void *)result;
85986   return jresult;
85987 }
85988
85989
85990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85991   void * jresult ;
85992   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85993   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85994
85995   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85996   {
85997     try {
85998       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85999     } catch (std::out_of_range& e) {
86000       {
86001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86002       };
86003     } catch (std::exception& e) {
86004       {
86005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86006       };
86007     } catch (Dali::DaliException e) {
86008       {
86009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86010       };
86011     } catch (...) {
86012       {
86013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86014       };
86015     }
86016   }
86017
86018   jresult = (void *)result;
86019   return jresult;
86020 }
86021
86022
86023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86024   void * jresult ;
86025   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86026   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86027
86028   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86029   {
86030     try {
86031       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86032     } catch (std::out_of_range& e) {
86033       {
86034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86035       };
86036     } catch (std::exception& e) {
86037       {
86038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86039       };
86040     } catch (Dali::DaliException e) {
86041       {
86042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86043       };
86044     } catch (...) {
86045       {
86046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86047       };
86048     }
86049   }
86050
86051   jresult = (void *)result;
86052   return jresult;
86053 }
86054
86055
86056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86057   void * jresult ;
86058   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86059   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86060
86061   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86062   {
86063     try {
86064       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86065     } catch (std::out_of_range& e) {
86066       {
86067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86068       };
86069     } catch (std::exception& e) {
86070       {
86071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86072       };
86073     } catch (Dali::DaliException e) {
86074       {
86075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86076       };
86077     } catch (...) {
86078       {
86079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86080       };
86081     }
86082   }
86083
86084   jresult = (void *)result;
86085   return jresult;
86086 }
86087
86088
86089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86090   void * jresult ;
86091   Dali::Toolkit::StyleManager *result = 0 ;
86092
86093   {
86094     try {
86095       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86096     } catch (std::out_of_range& e) {
86097       {
86098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86099       };
86100     } catch (std::exception& e) {
86101       {
86102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86103       };
86104     } catch (Dali::DaliException e) {
86105       {
86106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86107       };
86108     } catch (...) {
86109       {
86110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86111       };
86112     }
86113   }
86114
86115   jresult = (void *)result;
86116   return jresult;
86117 }
86118
86119
86120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86121   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86122
86123   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86124   {
86125     try {
86126       delete arg1;
86127     } catch (std::out_of_range& e) {
86128       {
86129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86130       };
86131     } catch (std::exception& e) {
86132       {
86133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86134       };
86135     } catch (Dali::DaliException e) {
86136       {
86137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86138       };
86139     } catch (...) {
86140       {
86141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86142       };
86143     }
86144   }
86145
86146 }
86147
86148
86149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86150   void * jresult ;
86151   Dali::Toolkit::StyleManager result;
86152
86153   {
86154     try {
86155       result = Dali::Toolkit::StyleManager::Get();
86156     } catch (std::out_of_range& e) {
86157       {
86158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86159       };
86160     } catch (std::exception& e) {
86161       {
86162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86163       };
86164     } catch (Dali::DaliException e) {
86165       {
86166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86167       };
86168     } catch (...) {
86169       {
86170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86171       };
86172     }
86173   }
86174
86175   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86176   return jresult;
86177 }
86178
86179
86180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86181   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86182   std::string *arg2 = 0 ;
86183
86184   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86185   if (!jarg2) {
86186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86187     return ;
86188   }
86189   std::string arg2_str(jarg2);
86190   arg2 = &arg2_str;
86191   {
86192     try {
86193       (arg1)->ApplyTheme((std::string const &)*arg2);
86194     } catch (std::out_of_range& e) {
86195       {
86196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86197       };
86198     } catch (std::exception& e) {
86199       {
86200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86201       };
86202     } catch (Dali::DaliException e) {
86203       {
86204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86205       };
86206     } catch (...) {
86207       {
86208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86209       };
86210     }
86211   }
86212
86213
86214   //argout typemap for const std::string&
86215
86216 }
86217
86218
86219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86220   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86221
86222   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86223   {
86224     try {
86225       (arg1)->ApplyDefaultTheme();
86226     } catch (std::out_of_range& e) {
86227       {
86228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86229       };
86230     } catch (std::exception& e) {
86231       {
86232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86233       };
86234     } catch (Dali::DaliException e) {
86235       {
86236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86237       };
86238     } catch (...) {
86239       {
86240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86241       };
86242     }
86243   }
86244
86245 }
86246
86247
86248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86249   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86250   std::string *arg2 = 0 ;
86251   Dali::Property::Value *arg3 = 0 ;
86252
86253   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86254   if (!jarg2) {
86255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86256     return ;
86257   }
86258   std::string arg2_str(jarg2);
86259   arg2 = &arg2_str;
86260   arg3 = (Dali::Property::Value *)jarg3;
86261   if (!arg3) {
86262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86263     return ;
86264   }
86265   {
86266     try {
86267       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86268     } catch (std::out_of_range& e) {
86269       {
86270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86271       };
86272     } catch (std::exception& e) {
86273       {
86274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86275       };
86276     } catch (Dali::DaliException e) {
86277       {
86278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86279       };
86280     } catch (...) {
86281       {
86282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86283       };
86284     }
86285   }
86286
86287
86288   //argout typemap for const std::string&
86289
86290 }
86291
86292
86293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86294   unsigned int jresult ;
86295   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86296   std::string *arg2 = 0 ;
86297   Dali::Property::Value *arg3 = 0 ;
86298   bool result;
86299
86300   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86301   if (!jarg2) {
86302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86303     return 0;
86304   }
86305   std::string arg2_str(jarg2);
86306   arg2 = &arg2_str;
86307   arg3 = (Dali::Property::Value *)jarg3;
86308   if (!arg3) {
86309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86310     return 0;
86311   }
86312   {
86313     try {
86314       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86315     } catch (std::out_of_range& e) {
86316       {
86317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86318       };
86319     } catch (std::exception& e) {
86320       {
86321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86322       };
86323     } catch (Dali::DaliException e) {
86324       {
86325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86326       };
86327     } catch (...) {
86328       {
86329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86330       };
86331     }
86332   }
86333
86334   jresult = result;
86335
86336   //argout typemap for const std::string&
86337
86338   return jresult;
86339 }
86340
86341
86342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86343   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86344   Dali::Toolkit::Control arg2 ;
86345   std::string *arg3 = 0 ;
86346   std::string *arg4 = 0 ;
86347   Dali::Toolkit::Control *argp2 ;
86348
86349   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86350   argp2 = (Dali::Toolkit::Control *)jarg2;
86351   if (!argp2) {
86352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86353     return ;
86354   }
86355   arg2 = *argp2;
86356   if (!jarg3) {
86357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86358     return ;
86359   }
86360   std::string arg3_str(jarg3);
86361   arg3 = &arg3_str;
86362   if (!jarg4) {
86363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86364     return ;
86365   }
86366   std::string arg4_str(jarg4);
86367   arg4 = &arg4_str;
86368   {
86369     try {
86370       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86371     } catch (std::out_of_range& e) {
86372       {
86373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86374       };
86375     } catch (std::exception& e) {
86376       {
86377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86378       };
86379     } catch (Dali::DaliException e) {
86380       {
86381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86382       };
86383     } catch (...) {
86384       {
86385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86386       };
86387     }
86388   }
86389
86390
86391   //argout typemap for const std::string&
86392
86393
86394   //argout typemap for const std::string&
86395
86396 }
86397
86398
86399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86400   void * jresult ;
86401   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86402   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86403
86404   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86405   {
86406     try {
86407       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86408     } catch (std::out_of_range& e) {
86409       {
86410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86411       };
86412     } catch (std::exception& e) {
86413       {
86414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86415       };
86416     } catch (Dali::DaliException e) {
86417       {
86418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86419       };
86420     } catch (...) {
86421       {
86422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86423       };
86424     }
86425   }
86426
86427   jresult = (void *)result;
86428   return jresult;
86429 }
86430
86431
86432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86433   int jresult ;
86434   int result;
86435
86436   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86437   jresult = (int)result;
86438   return jresult;
86439 }
86440
86441
86442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86443   int jresult ;
86444   int result;
86445
86446   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86447   jresult = (int)result;
86448   return jresult;
86449 }
86450
86451
86452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86453   int jresult ;
86454   int result;
86455
86456   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86457   jresult = (int)result;
86458   return jresult;
86459 }
86460
86461
86462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86463   int jresult ;
86464   int result;
86465
86466   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86467   jresult = (int)result;
86468   return jresult;
86469 }
86470
86471
86472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86473   int jresult ;
86474   int result;
86475
86476   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86477   jresult = (int)result;
86478   return jresult;
86479 }
86480
86481
86482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86483   int jresult ;
86484   int result;
86485
86486   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86487   jresult = (int)result;
86488   return jresult;
86489 }
86490
86491
86492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86493   int jresult ;
86494   int result;
86495
86496   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86497   jresult = (int)result;
86498   return jresult;
86499 }
86500
86501
86502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86503   int jresult ;
86504   int result;
86505
86506   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86507   jresult = (int)result;
86508   return jresult;
86509 }
86510
86511
86512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86513   int jresult ;
86514   int result;
86515
86516   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86517   jresult = (int)result;
86518   return jresult;
86519 }
86520
86521
86522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86523   int jresult ;
86524   int result;
86525
86526   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86527   jresult = (int)result;
86528   return jresult;
86529 }
86530
86531
86532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86533   int jresult ;
86534   int result;
86535
86536   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86537   jresult = (int)result;
86538   return jresult;
86539 }
86540
86541
86542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86543   int jresult ;
86544   int result;
86545
86546   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86547   jresult = (int)result;
86548   return jresult;
86549 }
86550
86551
86552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86553   int jresult ;
86554   int result;
86555
86556   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86557   jresult = (int)result;
86558   return jresult;
86559 }
86560
86561
86562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86563   int jresult ;
86564   int result;
86565
86566   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86567   jresult = (int)result;
86568   return jresult;
86569 }
86570
86571
86572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86573   int jresult ;
86574   int result;
86575
86576   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86577   jresult = (int)result;
86578   return jresult;
86579 }
86580
86581
86582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86583   void * jresult ;
86584   Dali::Toolkit::Slider::Property *result = 0 ;
86585
86586   {
86587     try {
86588       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86589     } catch (std::out_of_range& e) {
86590       {
86591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86592       };
86593     } catch (std::exception& e) {
86594       {
86595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86596       };
86597     } catch (Dali::DaliException e) {
86598       {
86599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86600       };
86601     } catch (...) {
86602       {
86603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86604       };
86605     }
86606   }
86607
86608   jresult = (void *)result;
86609   return jresult;
86610 }
86611
86612
86613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86614   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86615
86616   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86617   {
86618     try {
86619       delete arg1;
86620     } catch (std::out_of_range& e) {
86621       {
86622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86623       };
86624     } catch (std::exception& e) {
86625       {
86626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86627       };
86628     } catch (Dali::DaliException e) {
86629       {
86630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86631       };
86632     } catch (...) {
86633       {
86634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86635       };
86636     }
86637   }
86638
86639 }
86640
86641
86642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86643   void * jresult ;
86644   Dali::Toolkit::Slider result;
86645
86646   {
86647     try {
86648       result = Dali::Toolkit::Slider::New();
86649     } catch (std::out_of_range& e) {
86650       {
86651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86652       };
86653     } catch (std::exception& e) {
86654       {
86655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86656       };
86657     } catch (Dali::DaliException e) {
86658       {
86659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86660       };
86661     } catch (...) {
86662       {
86663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86664       };
86665     }
86666   }
86667
86668   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86669   return jresult;
86670 }
86671
86672
86673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86674   void * jresult ;
86675   Dali::Toolkit::Slider *result = 0 ;
86676
86677   {
86678     try {
86679       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86680     } catch (std::out_of_range& e) {
86681       {
86682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86683       };
86684     } catch (std::exception& e) {
86685       {
86686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86687       };
86688     } catch (Dali::DaliException e) {
86689       {
86690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86691       };
86692     } catch (...) {
86693       {
86694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86695       };
86696     }
86697   }
86698
86699   jresult = (void *)result;
86700   return jresult;
86701 }
86702
86703
86704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86705   void * jresult ;
86706   Dali::Toolkit::Slider *arg1 = 0 ;
86707   Dali::Toolkit::Slider *result = 0 ;
86708
86709   arg1 = (Dali::Toolkit::Slider *)jarg1;
86710   if (!arg1) {
86711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86712     return 0;
86713   }
86714   {
86715     try {
86716       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86717     } catch (std::out_of_range& e) {
86718       {
86719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86720       };
86721     } catch (std::exception& e) {
86722       {
86723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86724       };
86725     } catch (Dali::DaliException e) {
86726       {
86727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86728       };
86729     } catch (...) {
86730       {
86731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86732       };
86733     }
86734   }
86735
86736   jresult = (void *)result;
86737   return jresult;
86738 }
86739
86740
86741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86742   void * jresult ;
86743   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86744   Dali::Toolkit::Slider *arg2 = 0 ;
86745   Dali::Toolkit::Slider *result = 0 ;
86746
86747   arg1 = (Dali::Toolkit::Slider *)jarg1;
86748   arg2 = (Dali::Toolkit::Slider *)jarg2;
86749   if (!arg2) {
86750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86751     return 0;
86752   }
86753   {
86754     try {
86755       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86756     } catch (std::out_of_range& e) {
86757       {
86758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86759       };
86760     } catch (std::exception& e) {
86761       {
86762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86763       };
86764     } catch (Dali::DaliException e) {
86765       {
86766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86767       };
86768     } catch (...) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86771       };
86772     }
86773   }
86774
86775   jresult = (void *)result;
86776   return jresult;
86777 }
86778
86779
86780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86781   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86782
86783   arg1 = (Dali::Toolkit::Slider *)jarg1;
86784   {
86785     try {
86786       delete arg1;
86787     } catch (std::out_of_range& e) {
86788       {
86789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86790       };
86791     } catch (std::exception& e) {
86792       {
86793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86794       };
86795     } catch (Dali::DaliException e) {
86796       {
86797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86798       };
86799     } catch (...) {
86800       {
86801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86802       };
86803     }
86804   }
86805
86806 }
86807
86808
86809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86810   void * jresult ;
86811   Dali::BaseHandle arg1 ;
86812   Dali::BaseHandle *argp1 ;
86813   Dali::Toolkit::Slider result;
86814
86815   argp1 = (Dali::BaseHandle *)jarg1;
86816   if (!argp1) {
86817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86818     return 0;
86819   }
86820   arg1 = *argp1;
86821   {
86822     try {
86823       result = Dali::Toolkit::Slider::DownCast(arg1);
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 = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86844   return jresult;
86845 }
86846
86847
86848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
86849   void * jresult ;
86850   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86851   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86852
86853   arg1 = (Dali::Toolkit::Slider *)jarg1;
86854   {
86855     try {
86856       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
86857     } catch (std::out_of_range& e) {
86858       {
86859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86860       };
86861     } catch (std::exception& e) {
86862       {
86863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86864       };
86865     } catch (Dali::DaliException e) {
86866       {
86867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86868       };
86869     } catch (...) {
86870       {
86871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86872       };
86873     }
86874   }
86875
86876   jresult = (void *)result;
86877   return jresult;
86878 }
86879
86880
86881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
86882   void * jresult ;
86883   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86884   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86885
86886   arg1 = (Dali::Toolkit::Slider *)jarg1;
86887   {
86888     try {
86889       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
86890     } catch (std::out_of_range& e) {
86891       {
86892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86893       };
86894     } catch (std::exception& e) {
86895       {
86896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86897       };
86898     } catch (Dali::DaliException e) {
86899       {
86900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86901       };
86902     } catch (...) {
86903       {
86904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86905       };
86906     }
86907   }
86908
86909   jresult = (void *)result;
86910   return jresult;
86911 }
86912
86913
86914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86915   void * jresult ;
86916   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86917   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86918
86919   arg1 = (Dali::Toolkit::Slider *)jarg1;
86920   {
86921     try {
86922       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86923     } catch (std::out_of_range& e) {
86924       {
86925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86926       };
86927     } catch (std::exception& e) {
86928       {
86929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86930       };
86931     } catch (Dali::DaliException e) {
86932       {
86933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86934       };
86935     } catch (...) {
86936       {
86937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86938       };
86939     }
86940   }
86941
86942   jresult = (void *)result;
86943   return jresult;
86944 }
86945
86946
86947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86948   int jresult ;
86949   int result;
86950
86951   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86952   jresult = (int)result;
86953   return jresult;
86954 }
86955
86956
86957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86958   int jresult ;
86959   int result;
86960
86961   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86962   jresult = (int)result;
86963   return jresult;
86964 }
86965
86966
86967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86968   int jresult ;
86969   int result;
86970
86971   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86972   jresult = (int)result;
86973   return jresult;
86974 }
86975
86976
86977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86978   int jresult ;
86979   int result;
86980
86981   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86982   jresult = (int)result;
86983   return jresult;
86984 }
86985
86986
86987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86988   int result;
86989
86990   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86991
86992   return result;
86993 }
86994
86995
86996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86997   void * jresult ;
86998   Dali::Toolkit::VideoView::Property *result = 0 ;
86999
87000   {
87001     try {
87002       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87003     } catch (std::out_of_range& e) {
87004       {
87005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87006       };
87007     } catch (std::exception& e) {
87008       {
87009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87010       };
87011     } catch (Dali::DaliException e) {
87012       {
87013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87014       };
87015     } catch (...) {
87016       {
87017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87018       };
87019     }
87020   }
87021
87022   jresult = (void *)result;
87023   return jresult;
87024 }
87025
87026
87027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87028   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87029
87030   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87031   {
87032     try {
87033       delete arg1;
87034     } catch (std::out_of_range& e) {
87035       {
87036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87037       };
87038     } catch (std::exception& e) {
87039       {
87040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87041       };
87042     } catch (Dali::DaliException e) {
87043       {
87044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87045       };
87046     } catch (...) {
87047       {
87048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87049       };
87050     }
87051   }
87052
87053 }
87054
87055
87056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87057   void * jresult ;
87058   Dali::Toolkit::VideoView result;
87059
87060   {
87061     try {
87062       result = Dali::Toolkit::VideoView::New();
87063     } catch (std::out_of_range& e) {
87064       {
87065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87066       };
87067     } catch (std::exception& e) {
87068       {
87069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87070       };
87071     } catch (Dali::DaliException e) {
87072       {
87073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87074       };
87075     } catch (...) {
87076       {
87077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87078       };
87079     }
87080   }
87081
87082   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87083   return jresult;
87084 }
87085
87086
87087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87088   void * jresult ;
87089   std::string *arg1 = 0 ;
87090   Dali::Toolkit::VideoView result;
87091
87092   if (!jarg1) {
87093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87094     return 0;
87095   }
87096   std::string arg1_str(jarg1);
87097   arg1 = &arg1_str;
87098   {
87099     try {
87100       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87101     } catch (std::out_of_range& e) {
87102       {
87103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87104       };
87105     } catch (std::exception& e) {
87106       {
87107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87108       };
87109     } catch (Dali::DaliException e) {
87110       {
87111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87112       };
87113     } catch (...) {
87114       {
87115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87116       };
87117     }
87118   }
87119
87120   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87121
87122   //argout typemap for const std::string&
87123
87124   return jresult;
87125 }
87126
87127
87128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87129   void * jresult ;
87130   Dali::Toolkit::VideoView *result = 0 ;
87131
87132   {
87133     try {
87134       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87135     } catch (std::out_of_range& e) {
87136       {
87137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87138       };
87139     } catch (std::exception& e) {
87140       {
87141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87142       };
87143     } catch (Dali::DaliException e) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87146       };
87147     } catch (...) {
87148       {
87149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87150       };
87151     }
87152   }
87153
87154   jresult = (void *)result;
87155   return jresult;
87156 }
87157
87158
87159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87160   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87161
87162   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87163   {
87164     try {
87165       delete arg1;
87166     } catch (std::out_of_range& e) {
87167       {
87168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87169       };
87170     } catch (std::exception& e) {
87171       {
87172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87173       };
87174     } catch (Dali::DaliException e) {
87175       {
87176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87177       };
87178     } catch (...) {
87179       {
87180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87181       };
87182     }
87183   }
87184
87185 }
87186
87187
87188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87189   void * jresult ;
87190   Dali::Toolkit::VideoView *arg1 = 0 ;
87191   Dali::Toolkit::VideoView *result = 0 ;
87192
87193   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87194   if (!arg1) {
87195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87196     return 0;
87197   }
87198   {
87199     try {
87200       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87201     } catch (std::out_of_range& e) {
87202       {
87203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87204       };
87205     } catch (std::exception& e) {
87206       {
87207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87208       };
87209     } catch (Dali::DaliException e) {
87210       {
87211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87212       };
87213     } catch (...) {
87214       {
87215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87216       };
87217     }
87218   }
87219
87220   jresult = (void *)result;
87221   return jresult;
87222 }
87223
87224
87225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87226   void * jresult ;
87227   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87228   Dali::Toolkit::VideoView *arg2 = 0 ;
87229   Dali::Toolkit::VideoView *result = 0 ;
87230
87231   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87232   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87233   if (!arg2) {
87234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87235     return 0;
87236   }
87237   {
87238     try {
87239       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87240     } catch (std::out_of_range& e) {
87241       {
87242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87243       };
87244     } catch (std::exception& e) {
87245       {
87246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87247       };
87248     } catch (Dali::DaliException e) {
87249       {
87250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87251       };
87252     } catch (...) {
87253       {
87254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87255       };
87256     }
87257   }
87258
87259   jresult = (void *)result;
87260   return jresult;
87261 }
87262
87263
87264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87265   void * jresult ;
87266   Dali::BaseHandle arg1 ;
87267   Dali::BaseHandle *argp1 ;
87268   Dali::Toolkit::VideoView result;
87269
87270   argp1 = (Dali::BaseHandle *)jarg1;
87271   if (!argp1) {
87272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87273     return 0;
87274   }
87275   arg1 = *argp1;
87276   {
87277     try {
87278       result = Dali::Toolkit::VideoView::DownCast(arg1);
87279     } catch (std::out_of_range& e) {
87280       {
87281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87282       };
87283     } catch (std::exception& e) {
87284       {
87285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87286       };
87287     } catch (Dali::DaliException e) {
87288       {
87289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87290       };
87291     } catch (...) {
87292       {
87293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87294       };
87295     }
87296   }
87297
87298   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87299   return jresult;
87300 }
87301
87302
87303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87304   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87305
87306   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87307   {
87308     try {
87309       (arg1)->Play();
87310     } catch (std::out_of_range& e) {
87311       {
87312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87313       };
87314     } catch (std::exception& e) {
87315       {
87316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87317       };
87318     } catch (Dali::DaliException e) {
87319       {
87320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87321       };
87322     } catch (...) {
87323       {
87324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87325       };
87326     }
87327   }
87328
87329 }
87330
87331
87332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87333   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87334
87335   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87336   {
87337     try {
87338       (arg1)->Pause();
87339     } catch (std::out_of_range& e) {
87340       {
87341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87342       };
87343     } catch (std::exception& e) {
87344       {
87345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87346       };
87347     } catch (Dali::DaliException e) {
87348       {
87349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87350       };
87351     } catch (...) {
87352       {
87353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87354       };
87355     }
87356   }
87357
87358 }
87359
87360
87361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87362   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87363
87364   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87365   {
87366     try {
87367       (arg1)->Stop();
87368     } catch (std::out_of_range& e) {
87369       {
87370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87371       };
87372     } catch (std::exception& e) {
87373       {
87374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87375       };
87376     } catch (Dali::DaliException e) {
87377       {
87378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87379       };
87380     } catch (...) {
87381       {
87382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87383       };
87384     }
87385   }
87386
87387 }
87388
87389
87390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87391   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87392   int arg2 ;
87393
87394   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87395   arg2 = (int)jarg2;
87396   {
87397     try {
87398       (arg1)->Forward(arg2);
87399     } catch (std::out_of_range& e) {
87400       {
87401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87402       };
87403     } catch (std::exception& e) {
87404       {
87405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87406       };
87407     } catch (Dali::DaliException e) {
87408       {
87409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87410       };
87411     } catch (...) {
87412       {
87413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87414       };
87415     }
87416   }
87417
87418 }
87419
87420
87421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87422   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87423   int arg2 ;
87424
87425   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87426   arg2 = (int)jarg2;
87427   {
87428     try {
87429       (arg1)->Backward(arg2);
87430     } catch (std::out_of_range& e) {
87431       {
87432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87433       };
87434     } catch (std::exception& e) {
87435       {
87436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87437       };
87438     } catch (Dali::DaliException e) {
87439       {
87440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87441       };
87442     } catch (...) {
87443       {
87444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87445       };
87446     }
87447   }
87448
87449 }
87450
87451
87452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87453   void * jresult ;
87454   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87455   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87456
87457   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87458   {
87459     try {
87460       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87461     } catch (std::out_of_range& e) {
87462       {
87463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87464       };
87465     } catch (std::exception& e) {
87466       {
87467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87468       };
87469     } catch (Dali::DaliException e) {
87470       {
87471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87472       };
87473     } catch (...) {
87474       {
87475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87476       };
87477     }
87478   }
87479
87480   jresult = (void *)result;
87481   return jresult;
87482 }
87483
87484
87485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87486   int jresult ;
87487   int result;
87488
87489   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87490   jresult = (int)result;
87491   return jresult;
87492 }
87493
87494
87495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87496   int jresult ;
87497   int result;
87498
87499   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87500   jresult = (int)result;
87501   return jresult;
87502 }
87503
87504
87505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87506   int jresult ;
87507   int result;
87508
87509   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87510   jresult = (int)result;
87511   return jresult;
87512 }
87513
87514
87515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87516   int jresult ;
87517   int result;
87518
87519   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87520   jresult = (int)result;
87521   return jresult;
87522 }
87523
87524
87525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87526   int jresult ;
87527   int result;
87528
87529   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87530   jresult = (int)result;
87531   return jresult;
87532 }
87533
87534
87535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87536   int jresult ;
87537   int result;
87538
87539   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87540   jresult = (int)result;
87541   return jresult;
87542 }
87543
87544
87545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87546   int jresult ;
87547   int result;
87548
87549   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87550   jresult = (int)result;
87551   return jresult;
87552 }
87553
87554
87555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87556   int jresult ;
87557   int result;
87558
87559   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87560   jresult = (int)result;
87561   return jresult;
87562 }
87563
87564
87565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87566   int jresult ;
87567   int result;
87568
87569   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87570   jresult = (int)result;
87571   return jresult;
87572 }
87573
87574
87575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87576   int jresult ;
87577   int result;
87578
87579   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87580   jresult = (int)result;
87581   return jresult;
87582 }
87583
87584
87585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87586   int jresult ;
87587   int result;
87588
87589   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87590   jresult = (int)result;
87591   return jresult;
87592 }
87593
87594
87595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87596   int jresult ;
87597   int result;
87598
87599   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87600   jresult = (int)result;
87601   return jresult;
87602 }
87603
87604
87605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87606   int jresult ;
87607   int result;
87608
87609   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87610   jresult = (int)result;
87611   return jresult;
87612 }
87613
87614
87615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87616   int jresult ;
87617   int result;
87618
87619   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87620   jresult = (int)result;
87621   return jresult;
87622 }
87623
87624
87625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87626   int jresult ;
87627   int result;
87628
87629   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87630   jresult = (int)result;
87631   return jresult;
87632 }
87633
87634
87635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87636   int jresult ;
87637   int result;
87638
87639   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87640   jresult = (int)result;
87641   return jresult;
87642 }
87643
87644
87645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87646   int jresult ;
87647   int result;
87648
87649   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87650   jresult = (int)result;
87651   return jresult;
87652 }
87653
87654
87655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87656   int jresult ;
87657   int result;
87658
87659   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87660   jresult = (int)result;
87661   return jresult;
87662 }
87663
87664
87665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87666   int jresult ;
87667   int result;
87668
87669   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87670   jresult = (int)result;
87671   return jresult;
87672 }
87673
87674
87675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87676   int jresult ;
87677   int result;
87678
87679   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87680   jresult = (int)result;
87681   return jresult;
87682 }
87683
87684
87685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87686   int jresult ;
87687   int result;
87688
87689   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87690   jresult = (int)result;
87691   return jresult;
87692 }
87693
87694
87695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87696   void * jresult ;
87697   Dali::Toolkit::Popup::Property *result = 0 ;
87698
87699   {
87700     try {
87701       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87702     } catch (std::out_of_range& e) {
87703       {
87704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87705       };
87706     } catch (std::exception& e) {
87707       {
87708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87709       };
87710     } catch (Dali::DaliException e) {
87711       {
87712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87713       };
87714     } catch (...) {
87715       {
87716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87717       };
87718     }
87719   }
87720
87721   jresult = (void *)result;
87722   return jresult;
87723 }
87724
87725
87726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87727   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87728
87729   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87730   {
87731     try {
87732       delete arg1;
87733     } catch (std::out_of_range& e) {
87734       {
87735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87736       };
87737     } catch (std::exception& e) {
87738       {
87739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87740       };
87741     } catch (Dali::DaliException e) {
87742       {
87743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87744       };
87745     } catch (...) {
87746       {
87747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87748       };
87749     }
87750   }
87751
87752 }
87753
87754
87755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87756   void * jresult ;
87757   Dali::Toolkit::Popup *result = 0 ;
87758
87759   {
87760     try {
87761       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87762     } catch (std::out_of_range& e) {
87763       {
87764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87765       };
87766     } catch (std::exception& e) {
87767       {
87768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87769       };
87770     } catch (Dali::DaliException e) {
87771       {
87772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87773       };
87774     } catch (...) {
87775       {
87776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87777       };
87778     }
87779   }
87780
87781   jresult = (void *)result;
87782   return jresult;
87783 }
87784
87785
87786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87787   void * jresult ;
87788   Dali::Toolkit::Popup result;
87789
87790   {
87791     try {
87792       result = Dali::Toolkit::Popup::New();
87793     } catch (std::out_of_range& e) {
87794       {
87795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87796       };
87797     } catch (std::exception& e) {
87798       {
87799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87800       };
87801     } catch (Dali::DaliException e) {
87802       {
87803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87804       };
87805     } catch (...) {
87806       {
87807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87808       };
87809     }
87810   }
87811
87812   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87813   return jresult;
87814 }
87815
87816
87817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87818   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87819
87820   arg1 = (Dali::Toolkit::Popup *)jarg1;
87821   {
87822     try {
87823       delete arg1;
87824     } catch (std::out_of_range& e) {
87825       {
87826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87827       };
87828     } catch (std::exception& e) {
87829       {
87830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87831       };
87832     } catch (Dali::DaliException e) {
87833       {
87834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87835       };
87836     } catch (...) {
87837       {
87838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87839       };
87840     }
87841   }
87842
87843 }
87844
87845
87846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87847   void * jresult ;
87848   Dali::Toolkit::Popup *arg1 = 0 ;
87849   Dali::Toolkit::Popup *result = 0 ;
87850
87851   arg1 = (Dali::Toolkit::Popup *)jarg1;
87852   if (!arg1) {
87853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87854     return 0;
87855   }
87856   {
87857     try {
87858       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87859     } catch (std::out_of_range& e) {
87860       {
87861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87862       };
87863     } catch (std::exception& e) {
87864       {
87865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87866       };
87867     } catch (Dali::DaliException e) {
87868       {
87869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87870       };
87871     } catch (...) {
87872       {
87873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87874       };
87875     }
87876   }
87877
87878   jresult = (void *)result;
87879   return jresult;
87880 }
87881
87882
87883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87884   void * jresult ;
87885   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87886   Dali::Toolkit::Popup *arg2 = 0 ;
87887   Dali::Toolkit::Popup *result = 0 ;
87888
87889   arg1 = (Dali::Toolkit::Popup *)jarg1;
87890   arg2 = (Dali::Toolkit::Popup *)jarg2;
87891   if (!arg2) {
87892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87893     return 0;
87894   }
87895   {
87896     try {
87897       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87898     } catch (std::out_of_range& e) {
87899       {
87900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87901       };
87902     } catch (std::exception& e) {
87903       {
87904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87905       };
87906     } catch (Dali::DaliException e) {
87907       {
87908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87909       };
87910     } catch (...) {
87911       {
87912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87913       };
87914     }
87915   }
87916
87917   jresult = (void *)result;
87918   return jresult;
87919 }
87920
87921
87922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87923   void * jresult ;
87924   Dali::BaseHandle arg1 ;
87925   Dali::BaseHandle *argp1 ;
87926   Dali::Toolkit::Popup result;
87927
87928   argp1 = (Dali::BaseHandle *)jarg1;
87929   if (!argp1) {
87930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87931     return 0;
87932   }
87933   arg1 = *argp1;
87934   {
87935     try {
87936       result = Dali::Toolkit::Popup::DownCast(arg1);
87937     } catch (std::out_of_range& e) {
87938       {
87939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87940       };
87941     } catch (std::exception& e) {
87942       {
87943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87944       };
87945     } catch (Dali::DaliException e) {
87946       {
87947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87948       };
87949     } catch (...) {
87950       {
87951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87952       };
87953     }
87954   }
87955
87956   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87957   return jresult;
87958 }
87959
87960
87961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87962   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87963   Dali::Actor arg2 ;
87964   Dali::Actor *argp2 ;
87965
87966   arg1 = (Dali::Toolkit::Popup *)jarg1;
87967   argp2 = (Dali::Actor *)jarg2;
87968   if (!argp2) {
87969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87970     return ;
87971   }
87972   arg2 = *argp2;
87973   {
87974     try {
87975       (arg1)->SetTitle(arg2);
87976     } catch (std::out_of_range& e) {
87977       {
87978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87979       };
87980     } catch (std::exception& e) {
87981       {
87982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87983       };
87984     } catch (Dali::DaliException e) {
87985       {
87986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87987       };
87988     } catch (...) {
87989       {
87990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87991       };
87992     }
87993   }
87994
87995 }
87996
87997
87998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87999   void * jresult ;
88000   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88001   Dali::Actor result;
88002
88003   arg1 = (Dali::Toolkit::Popup *)jarg1;
88004   {
88005     try {
88006       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
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::Actor((const Dali::Actor &)result);
88027   return jresult;
88028 }
88029
88030
88031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88032   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88033   Dali::Actor arg2 ;
88034   Dali::Actor *argp2 ;
88035
88036   arg1 = (Dali::Toolkit::Popup *)jarg1;
88037   argp2 = (Dali::Actor *)jarg2;
88038   if (!argp2) {
88039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88040     return ;
88041   }
88042   arg2 = *argp2;
88043   {
88044     try {
88045       (arg1)->SetContent(arg2);
88046     } catch (std::out_of_range& e) {
88047       {
88048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88049       };
88050     } catch (std::exception& e) {
88051       {
88052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88053       };
88054     } catch (Dali::DaliException e) {
88055       {
88056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88057       };
88058     } catch (...) {
88059       {
88060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88061       };
88062     }
88063   }
88064
88065 }
88066
88067
88068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88069   void * jresult ;
88070   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88071   Dali::Actor result;
88072
88073   arg1 = (Dali::Toolkit::Popup *)jarg1;
88074   {
88075     try {
88076       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88077     } catch (std::out_of_range& e) {
88078       {
88079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88080       };
88081     } catch (std::exception& e) {
88082       {
88083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88084       };
88085     } catch (Dali::DaliException e) {
88086       {
88087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88088       };
88089     } catch (...) {
88090       {
88091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88092       };
88093     }
88094   }
88095
88096   jresult = new Dali::Actor((const Dali::Actor &)result);
88097   return jresult;
88098 }
88099
88100
88101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88102   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88103   Dali::Actor arg2 ;
88104   Dali::Actor *argp2 ;
88105
88106   arg1 = (Dali::Toolkit::Popup *)jarg1;
88107   argp2 = (Dali::Actor *)jarg2;
88108   if (!argp2) {
88109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88110     return ;
88111   }
88112   arg2 = *argp2;
88113   {
88114     try {
88115       (arg1)->SetFooter(arg2);
88116     } catch (std::out_of_range& e) {
88117       {
88118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88119       };
88120     } catch (std::exception& e) {
88121       {
88122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88123       };
88124     } catch (Dali::DaliException e) {
88125       {
88126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88127       };
88128     } catch (...) {
88129       {
88130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88131       };
88132     }
88133   }
88134
88135 }
88136
88137
88138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88139   void * jresult ;
88140   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88141   Dali::Actor result;
88142
88143   arg1 = (Dali::Toolkit::Popup *)jarg1;
88144   {
88145     try {
88146       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88147     } catch (std::out_of_range& e) {
88148       {
88149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88150       };
88151     } catch (std::exception& e) {
88152       {
88153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88154       };
88155     } catch (Dali::DaliException e) {
88156       {
88157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88158       };
88159     } catch (...) {
88160       {
88161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88162       };
88163     }
88164   }
88165
88166   jresult = new Dali::Actor((const Dali::Actor &)result);
88167   return jresult;
88168 }
88169
88170
88171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88172   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88173   Dali::Toolkit::Popup::DisplayState arg2 ;
88174
88175   arg1 = (Dali::Toolkit::Popup *)jarg1;
88176   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88177   {
88178     try {
88179       (arg1)->SetDisplayState(arg2);
88180     } catch (std::out_of_range& e) {
88181       {
88182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88183       };
88184     } catch (std::exception& e) {
88185       {
88186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88187       };
88188     } catch (Dali::DaliException e) {
88189       {
88190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88191       };
88192     } catch (...) {
88193       {
88194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88195       };
88196     }
88197   }
88198
88199 }
88200
88201
88202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88203   int jresult ;
88204   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88205   Dali::Toolkit::Popup::DisplayState result;
88206
88207   arg1 = (Dali::Toolkit::Popup *)jarg1;
88208   {
88209     try {
88210       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88211     } catch (std::out_of_range& e) {
88212       {
88213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88214       };
88215     } catch (std::exception& e) {
88216       {
88217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88218       };
88219     } catch (Dali::DaliException e) {
88220       {
88221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88222       };
88223     } catch (...) {
88224       {
88225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88226       };
88227     }
88228   }
88229
88230   jresult = (int)result;
88231   return jresult;
88232 }
88233
88234
88235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88236   void * jresult ;
88237   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88238   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88239
88240   arg1 = (Dali::Toolkit::Popup *)jarg1;
88241   {
88242     try {
88243       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88244     } catch (std::out_of_range& e) {
88245       {
88246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88247       };
88248     } catch (std::exception& e) {
88249       {
88250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88251       };
88252     } catch (Dali::DaliException e) {
88253       {
88254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88255       };
88256     } catch (...) {
88257       {
88258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88259       };
88260     }
88261   }
88262
88263   jresult = (void *)result;
88264   return jresult;
88265 }
88266
88267
88268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88269   void * jresult ;
88270   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88271   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88272
88273   arg1 = (Dali::Toolkit::Popup *)jarg1;
88274   {
88275     try {
88276       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88277     } catch (std::out_of_range& e) {
88278       {
88279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88280       };
88281     } catch (std::exception& e) {
88282       {
88283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88284       };
88285     } catch (Dali::DaliException e) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88288       };
88289     } catch (...) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88292       };
88293     }
88294   }
88295
88296   jresult = (void *)result;
88297   return jresult;
88298 }
88299
88300
88301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88302   void * jresult ;
88303   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88304   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88305
88306   arg1 = (Dali::Toolkit::Popup *)jarg1;
88307   {
88308     try {
88309       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88310     } catch (std::out_of_range& e) {
88311       {
88312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88313       };
88314     } catch (std::exception& e) {
88315       {
88316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88317       };
88318     } catch (Dali::DaliException e) {
88319       {
88320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88321       };
88322     } catch (...) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88325       };
88326     }
88327   }
88328
88329   jresult = (void *)result;
88330   return jresult;
88331 }
88332
88333
88334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88335   void * jresult ;
88336   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88337   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88338
88339   arg1 = (Dali::Toolkit::Popup *)jarg1;
88340   {
88341     try {
88342       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88343     } catch (std::out_of_range& e) {
88344       {
88345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88346       };
88347     } catch (std::exception& e) {
88348       {
88349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88350       };
88351     } catch (Dali::DaliException e) {
88352       {
88353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88354       };
88355     } catch (...) {
88356       {
88357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88358       };
88359     }
88360   }
88361
88362   jresult = (void *)result;
88363   return jresult;
88364 }
88365
88366
88367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88368   void * jresult ;
88369   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88370   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88371
88372   arg1 = (Dali::Toolkit::Popup *)jarg1;
88373   {
88374     try {
88375       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88376     } catch (std::out_of_range& e) {
88377       {
88378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88379       };
88380     } catch (std::exception& e) {
88381       {
88382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88383       };
88384     } catch (Dali::DaliException e) {
88385       {
88386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88387       };
88388     } catch (...) {
88389       {
88390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88391       };
88392     }
88393   }
88394
88395   jresult = (void *)result;
88396   return jresult;
88397 }
88398
88399
88400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88401   int jresult ;
88402   int result;
88403
88404   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88405   jresult = (int)result;
88406   return jresult;
88407 }
88408
88409
88410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88411   int jresult ;
88412   int result;
88413
88414   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88415   jresult = (int)result;
88416   return jresult;
88417 }
88418
88419
88420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88421   int jresult ;
88422   int result;
88423
88424   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88425   jresult = (int)result;
88426   return jresult;
88427 }
88428
88429
88430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88431   int jresult ;
88432   int result;
88433
88434   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88435   jresult = (int)result;
88436   return jresult;
88437 }
88438
88439
88440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88441   int jresult ;
88442   int result;
88443
88444   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88445   jresult = (int)result;
88446   return jresult;
88447 }
88448
88449
88450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88451   int jresult ;
88452   int result;
88453
88454   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88455   jresult = (int)result;
88456   return jresult;
88457 }
88458
88459
88460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88461   int jresult ;
88462   int result;
88463
88464   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88465   jresult = (int)result;
88466   return jresult;
88467 }
88468
88469
88470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88471   int jresult ;
88472   int result;
88473
88474   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88475   jresult = (int)result;
88476   return jresult;
88477 }
88478
88479
88480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88481   int jresult ;
88482   int result;
88483
88484   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88485   jresult = (int)result;
88486   return jresult;
88487 }
88488
88489
88490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88491   void * jresult ;
88492   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88493
88494   {
88495     try {
88496       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88497     } catch (std::out_of_range& e) {
88498       {
88499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88500       };
88501     } catch (std::exception& e) {
88502       {
88503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88504       };
88505     } catch (Dali::DaliException e) {
88506       {
88507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88508       };
88509     } catch (...) {
88510       {
88511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88512       };
88513     }
88514   }
88515
88516   jresult = (void *)result;
88517   return jresult;
88518 }
88519
88520
88521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88522   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88523
88524   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88525   {
88526     try {
88527       delete arg1;
88528     } catch (std::out_of_range& e) {
88529       {
88530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88531       };
88532     } catch (std::exception& e) {
88533       {
88534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88535       };
88536     } catch (Dali::DaliException e) {
88537       {
88538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88539       };
88540     } catch (...) {
88541       {
88542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88543       };
88544     }
88545   }
88546
88547 }
88548
88549
88550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88551   void * jresult ;
88552   Dali::Toolkit::ProgressBar result;
88553
88554   {
88555     try {
88556       result = Dali::Toolkit::ProgressBar::New();
88557     } catch (std::out_of_range& e) {
88558       {
88559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88560       };
88561     } catch (std::exception& e) {
88562       {
88563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88564       };
88565     } catch (Dali::DaliException e) {
88566       {
88567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88568       };
88569     } catch (...) {
88570       {
88571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88572       };
88573     }
88574   }
88575
88576   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88577   return jresult;
88578 }
88579
88580
88581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88582   void * jresult ;
88583   Dali::Toolkit::ProgressBar *result = 0 ;
88584
88585   {
88586     try {
88587       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88588     } catch (std::out_of_range& e) {
88589       {
88590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88591       };
88592     } catch (std::exception& e) {
88593       {
88594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88595       };
88596     } catch (Dali::DaliException e) {
88597       {
88598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88599       };
88600     } catch (...) {
88601       {
88602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88603       };
88604     }
88605   }
88606
88607   jresult = (void *)result;
88608   return jresult;
88609 }
88610
88611
88612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88613   void * jresult ;
88614   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88615   Dali::Toolkit::ProgressBar *result = 0 ;
88616
88617   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88618   if (!arg1) {
88619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88620     return 0;
88621   }
88622   {
88623     try {
88624       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88625     } catch (std::out_of_range& e) {
88626       {
88627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88628       };
88629     } catch (std::exception& e) {
88630       {
88631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88632       };
88633     } catch (Dali::DaliException e) {
88634       {
88635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88636       };
88637     } catch (...) {
88638       {
88639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88640       };
88641     }
88642   }
88643
88644   jresult = (void *)result;
88645   return jresult;
88646 }
88647
88648
88649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88650   void * jresult ;
88651   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88652   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88653   Dali::Toolkit::ProgressBar *result = 0 ;
88654
88655   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88656   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88657   if (!arg2) {
88658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88659     return 0;
88660   }
88661   {
88662     try {
88663       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88664     } catch (std::out_of_range& e) {
88665       {
88666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88667       };
88668     } catch (std::exception& e) {
88669       {
88670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88671       };
88672     } catch (Dali::DaliException e) {
88673       {
88674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88675       };
88676     } catch (...) {
88677       {
88678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88679       };
88680     }
88681   }
88682
88683   jresult = (void *)result;
88684   return jresult;
88685 }
88686
88687
88688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88689   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88690
88691   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88692   {
88693     try {
88694       delete arg1;
88695     } catch (std::out_of_range& e) {
88696       {
88697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88698       };
88699     } catch (std::exception& e) {
88700       {
88701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88702       };
88703     } catch (Dali::DaliException e) {
88704       {
88705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88706       };
88707     } catch (...) {
88708       {
88709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88710       };
88711     }
88712   }
88713
88714 }
88715
88716
88717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88718   void * jresult ;
88719   Dali::BaseHandle arg1 ;
88720   Dali::BaseHandle *argp1 ;
88721   Dali::Toolkit::ProgressBar result;
88722
88723   argp1 = (Dali::BaseHandle *)jarg1;
88724   if (!argp1) {
88725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88726     return 0;
88727   }
88728   arg1 = *argp1;
88729   {
88730     try {
88731       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88732     } catch (std::out_of_range& e) {
88733       {
88734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88735       };
88736     } catch (std::exception& e) {
88737       {
88738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88739       };
88740     } catch (Dali::DaliException e) {
88741       {
88742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88743       };
88744     } catch (...) {
88745       {
88746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88747       };
88748     }
88749   }
88750
88751   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88752   return jresult;
88753 }
88754
88755
88756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88757   void * jresult ;
88758   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88759   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88760
88761   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88762   {
88763     try {
88764       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88765     } catch (std::out_of_range& e) {
88766       {
88767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88768       };
88769     } catch (std::exception& e) {
88770       {
88771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88772       };
88773     } catch (Dali::DaliException e) {
88774       {
88775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88776       };
88777     } catch (...) {
88778       {
88779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88780       };
88781     }
88782   }
88783
88784   jresult = (void *)result;
88785   return jresult;
88786 }
88787
88788
88789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88790   void * jresult ;
88791   Dali::Toolkit::GaussianBlurView *result = 0 ;
88792
88793   {
88794     try {
88795       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88796     } catch (std::out_of_range& e) {
88797       {
88798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88799       };
88800     } catch (std::exception& e) {
88801       {
88802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88803       };
88804     } catch (Dali::DaliException e) {
88805       {
88806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88807       };
88808     } catch (...) {
88809       {
88810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88811       };
88812     }
88813   }
88814
88815   jresult = (void *)result;
88816   return jresult;
88817 }
88818
88819
88820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88821   void * jresult ;
88822   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88823   Dali::Toolkit::GaussianBlurView *result = 0 ;
88824
88825   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88826   if (!arg1) {
88827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88828     return 0;
88829   }
88830   {
88831     try {
88832       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88833     } catch (std::out_of_range& e) {
88834       {
88835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88836       };
88837     } catch (std::exception& e) {
88838       {
88839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88840       };
88841     } catch (Dali::DaliException e) {
88842       {
88843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88844       };
88845     } catch (...) {
88846       {
88847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88848       };
88849     }
88850   }
88851
88852   jresult = (void *)result;
88853   return jresult;
88854 }
88855
88856
88857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88858   void * jresult ;
88859   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88860   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88861   Dali::Toolkit::GaussianBlurView *result = 0 ;
88862
88863   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88864   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88865   if (!arg2) {
88866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88867     return 0;
88868   }
88869   {
88870     try {
88871       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88872     } catch (std::out_of_range& e) {
88873       {
88874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88875       };
88876     } catch (std::exception& e) {
88877       {
88878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88879       };
88880     } catch (Dali::DaliException e) {
88881       {
88882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88883       };
88884     } catch (...) {
88885       {
88886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88887       };
88888     }
88889   }
88890
88891   jresult = (void *)result;
88892   return jresult;
88893 }
88894
88895
88896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88897   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88898
88899   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88900   {
88901     try {
88902       delete arg1;
88903     } catch (std::out_of_range& e) {
88904       {
88905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88906       };
88907     } catch (std::exception& e) {
88908       {
88909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88910       };
88911     } catch (Dali::DaliException e) {
88912       {
88913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88914       };
88915     } catch (...) {
88916       {
88917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88918       };
88919     }
88920   }
88921
88922 }
88923
88924
88925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88926   void * jresult ;
88927   Dali::BaseHandle arg1 ;
88928   Dali::BaseHandle *argp1 ;
88929   Dali::Toolkit::GaussianBlurView result;
88930
88931   argp1 = (Dali::BaseHandle *)jarg1;
88932   if (!argp1) {
88933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88934     return 0;
88935   }
88936   arg1 = *argp1;
88937   {
88938     try {
88939       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88940     } catch (std::out_of_range& e) {
88941       {
88942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88943       };
88944     } catch (std::exception& e) {
88945       {
88946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88947       };
88948     } catch (Dali::DaliException e) {
88949       {
88950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88951       };
88952     } catch (...) {
88953       {
88954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88955       };
88956     }
88957   }
88958
88959   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88960   return jresult;
88961 }
88962
88963
88964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88965   void * jresult ;
88966   Dali::Toolkit::GaussianBlurView result;
88967
88968   {
88969     try {
88970       result = Dali::Toolkit::GaussianBlurView::New();
88971     } catch (std::out_of_range& e) {
88972       {
88973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88974       };
88975     } catch (std::exception& e) {
88976       {
88977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88978       };
88979     } catch (Dali::DaliException e) {
88980       {
88981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88982       };
88983     } catch (...) {
88984       {
88985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88986       };
88987     }
88988   }
88989
88990   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88991   return jresult;
88992 }
88993
88994
88995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88996   void * jresult ;
88997   unsigned int arg1 ;
88998   float arg2 ;
88999   Dali::Pixel::Format arg3 ;
89000   float arg4 ;
89001   float arg5 ;
89002   bool arg6 ;
89003   Dali::Toolkit::GaussianBlurView result;
89004
89005   arg1 = (unsigned int)jarg1;
89006   arg2 = (float)jarg2;
89007   arg3 = (Dali::Pixel::Format)jarg3;
89008   arg4 = (float)jarg4;
89009   arg5 = (float)jarg5;
89010   arg6 = jarg6 ? true : false;
89011   {
89012     try {
89013       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89014     } catch (std::out_of_range& e) {
89015       {
89016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89017       };
89018     } catch (std::exception& e) {
89019       {
89020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89021       };
89022     } catch (Dali::DaliException e) {
89023       {
89024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89025       };
89026     } catch (...) {
89027       {
89028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89029       };
89030     }
89031   }
89032
89033   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89034   return jresult;
89035 }
89036
89037
89038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89039   void * jresult ;
89040   unsigned int arg1 ;
89041   float arg2 ;
89042   Dali::Pixel::Format arg3 ;
89043   float arg4 ;
89044   float arg5 ;
89045   Dali::Toolkit::GaussianBlurView result;
89046
89047   arg1 = (unsigned int)jarg1;
89048   arg2 = (float)jarg2;
89049   arg3 = (Dali::Pixel::Format)jarg3;
89050   arg4 = (float)jarg4;
89051   arg5 = (float)jarg5;
89052   {
89053     try {
89054       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89055     } catch (std::out_of_range& e) {
89056       {
89057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89058       };
89059     } catch (std::exception& e) {
89060       {
89061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89062       };
89063     } catch (Dali::DaliException e) {
89064       {
89065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89066       };
89067     } catch (...) {
89068       {
89069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89070       };
89071     }
89072   }
89073
89074   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89075   return jresult;
89076 }
89077
89078
89079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89080   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89081   Dali::Actor arg2 ;
89082   Dali::Actor *argp2 ;
89083
89084   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89085   argp2 = (Dali::Actor *)jarg2;
89086   if (!argp2) {
89087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89088     return ;
89089   }
89090   arg2 = *argp2;
89091   {
89092     try {
89093       (arg1)->Add(arg2);
89094     } catch (std::out_of_range& e) {
89095       {
89096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89097       };
89098     } catch (std::exception& e) {
89099       {
89100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89101       };
89102     } catch (Dali::DaliException e) {
89103       {
89104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89105       };
89106     } catch (...) {
89107       {
89108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89109       };
89110     }
89111   }
89112
89113 }
89114
89115
89116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89117   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89118   Dali::Actor arg2 ;
89119   Dali::Actor *argp2 ;
89120
89121   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89122   argp2 = (Dali::Actor *)jarg2;
89123   if (!argp2) {
89124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89125     return ;
89126   }
89127   arg2 = *argp2;
89128   {
89129     try {
89130       (arg1)->Remove(arg2);
89131     } catch (std::out_of_range& e) {
89132       {
89133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89134       };
89135     } catch (std::exception& e) {
89136       {
89137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89138       };
89139     } catch (Dali::DaliException e) {
89140       {
89141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89142       };
89143     } catch (...) {
89144       {
89145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89146       };
89147     }
89148   }
89149
89150 }
89151
89152
89153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89154   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89155
89156   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89157   {
89158     try {
89159       (arg1)->Activate();
89160     } catch (std::out_of_range& e) {
89161       {
89162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89163       };
89164     } catch (std::exception& e) {
89165       {
89166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89167       };
89168     } catch (Dali::DaliException e) {
89169       {
89170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89171       };
89172     } catch (...) {
89173       {
89174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89175       };
89176     }
89177   }
89178
89179 }
89180
89181
89182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89183   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89184
89185   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89186   {
89187     try {
89188       (arg1)->ActivateOnce();
89189     } catch (std::out_of_range& e) {
89190       {
89191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89192       };
89193     } catch (std::exception& e) {
89194       {
89195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89196       };
89197     } catch (Dali::DaliException e) {
89198       {
89199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89200       };
89201     } catch (...) {
89202       {
89203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89204       };
89205     }
89206   }
89207
89208 }
89209
89210
89211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89212   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89213
89214   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89215   {
89216     try {
89217       (arg1)->Deactivate();
89218     } catch (std::out_of_range& e) {
89219       {
89220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89221       };
89222     } catch (std::exception& e) {
89223       {
89224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89225       };
89226     } catch (Dali::DaliException e) {
89227       {
89228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89229       };
89230     } catch (...) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89233       };
89234     }
89235   }
89236
89237 }
89238
89239
89240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89241   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89242   Dali::Image arg2 ;
89243   Dali::FrameBufferImage arg3 ;
89244   Dali::Image *argp2 ;
89245   Dali::FrameBufferImage *argp3 ;
89246
89247   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89248   argp2 = (Dali::Image *)jarg2;
89249   if (!argp2) {
89250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89251     return ;
89252   }
89253   arg2 = *argp2;
89254   argp3 = (Dali::FrameBufferImage *)jarg3;
89255   if (!argp3) {
89256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89257     return ;
89258   }
89259   arg3 = *argp3;
89260   {
89261     try {
89262       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89263     } catch (std::out_of_range& e) {
89264       {
89265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89266       };
89267     } catch (std::exception& e) {
89268       {
89269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89270       };
89271     } catch (Dali::DaliException e) {
89272       {
89273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89274       };
89275     } catch (...) {
89276       {
89277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89278       };
89279     }
89280   }
89281
89282 }
89283
89284
89285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89286   int jresult ;
89287   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89288   Dali::Property::Index result;
89289
89290   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89291   {
89292     try {
89293       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89294     } catch (std::out_of_range& e) {
89295       {
89296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89297       };
89298     } catch (std::exception& e) {
89299       {
89300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89301       };
89302     } catch (Dali::DaliException e) {
89303       {
89304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89305       };
89306     } catch (...) {
89307       {
89308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89309       };
89310     }
89311   }
89312
89313   jresult = result;
89314   return jresult;
89315 }
89316
89317
89318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89319   void * jresult ;
89320   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89321   Dali::FrameBufferImage result;
89322
89323   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89324   {
89325     try {
89326       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89327     } catch (std::out_of_range& e) {
89328       {
89329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89330       };
89331     } catch (std::exception& e) {
89332       {
89333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89334       };
89335     } catch (Dali::DaliException e) {
89336       {
89337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89338       };
89339     } catch (...) {
89340       {
89341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89342       };
89343     }
89344   }
89345
89346   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89347   return jresult;
89348 }
89349
89350
89351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89352   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89353   Dali::Vector4 *arg2 = 0 ;
89354
89355   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89356   arg2 = (Dali::Vector4 *)jarg2;
89357   if (!arg2) {
89358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89359     return ;
89360   }
89361   {
89362     try {
89363       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89364     } catch (std::out_of_range& e) {
89365       {
89366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89367       };
89368     } catch (std::exception& e) {
89369       {
89370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89371       };
89372     } catch (Dali::DaliException e) {
89373       {
89374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89375       };
89376     } catch (...) {
89377       {
89378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89379       };
89380     }
89381   }
89382
89383 }
89384
89385
89386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89387   void * jresult ;
89388   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89389   Dali::Vector4 result;
89390
89391   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89392   {
89393     try {
89394       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89395     } catch (std::out_of_range& e) {
89396       {
89397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89398       };
89399     } catch (std::exception& e) {
89400       {
89401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89402       };
89403     } catch (Dali::DaliException e) {
89404       {
89405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89406       };
89407     } catch (...) {
89408       {
89409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89410       };
89411     }
89412   }
89413
89414   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89415   return jresult;
89416 }
89417
89418
89419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89420   void * jresult ;
89421   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89422   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89423
89424   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89425   {
89426     try {
89427       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89428     } catch (std::out_of_range& e) {
89429       {
89430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89431       };
89432     } catch (std::exception& e) {
89433       {
89434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89435       };
89436     } catch (Dali::DaliException e) {
89437       {
89438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89439       };
89440     } catch (...) {
89441       {
89442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89443       };
89444     }
89445   }
89446
89447   jresult = (void *)result;
89448   return jresult;
89449 }
89450
89451
89452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89453   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89454
89455   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89456   {
89457     try {
89458       delete arg1;
89459     } catch (std::out_of_range& e) {
89460       {
89461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89462       };
89463     } catch (std::exception& e) {
89464       {
89465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89466       };
89467     } catch (Dali::DaliException e) {
89468       {
89469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89470       };
89471     } catch (...) {
89472       {
89473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89474       };
89475     }
89476   }
89477
89478 }
89479
89480
89481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89482   unsigned int jresult ;
89483   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89484   unsigned int result;
89485
89486   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89487   {
89488     try {
89489       result = (unsigned int)(arg1)->GetNumberOfPages();
89490     } catch (std::out_of_range& e) {
89491       {
89492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89493       };
89494     } catch (std::exception& e) {
89495       {
89496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89497       };
89498     } catch (Dali::DaliException e) {
89499       {
89500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89501       };
89502     } catch (...) {
89503       {
89504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89505       };
89506     }
89507   }
89508
89509   jresult = result;
89510   return jresult;
89511 }
89512
89513
89514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89515   void * jresult ;
89516   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89517   unsigned int arg2 ;
89518   Dali::Texture result;
89519
89520   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89521   arg2 = (unsigned int)jarg2;
89522   {
89523     try {
89524       result = (arg1)->NewPage(arg2);
89525     } catch (std::out_of_range& e) {
89526       {
89527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89528       };
89529     } catch (std::exception& e) {
89530       {
89531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89532       };
89533     } catch (Dali::DaliException e) {
89534       {
89535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89536       };
89537     } catch (...) {
89538       {
89539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89540       };
89541     }
89542   }
89543
89544   jresult = new Dali::Texture((const Dali::Texture &)result);
89545   return jresult;
89546 }
89547
89548
89549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89550   int jresult ;
89551   int result;
89552
89553   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89554   jresult = (int)result;
89555   return jresult;
89556 }
89557
89558
89559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89560   int jresult ;
89561   int result;
89562
89563   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89564   jresult = (int)result;
89565   return jresult;
89566 }
89567
89568
89569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89570   int jresult ;
89571   int result;
89572
89573   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89574   jresult = (int)result;
89575   return jresult;
89576 }
89577
89578
89579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89580   void * jresult ;
89581   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89582
89583   {
89584     try {
89585       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89586     } catch (std::out_of_range& e) {
89587       {
89588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89589       };
89590     } catch (std::exception& e) {
89591       {
89592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89593       };
89594     } catch (Dali::DaliException e) {
89595       {
89596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89597       };
89598     } catch (...) {
89599       {
89600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89601       };
89602     }
89603   }
89604
89605   jresult = (void *)result;
89606   return jresult;
89607 }
89608
89609
89610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89611   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89612
89613   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89614   {
89615     try {
89616       delete arg1;
89617     } catch (std::out_of_range& e) {
89618       {
89619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89620       };
89621     } catch (std::exception& e) {
89622       {
89623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89624       };
89625     } catch (Dali::DaliException e) {
89626       {
89627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89628       };
89629     } catch (...) {
89630       {
89631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89632       };
89633     }
89634   }
89635
89636 }
89637
89638
89639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89640   void * jresult ;
89641   Dali::Toolkit::PageTurnView *result = 0 ;
89642
89643   {
89644     try {
89645       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89646     } catch (std::out_of_range& e) {
89647       {
89648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89649       };
89650     } catch (std::exception& e) {
89651       {
89652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89653       };
89654     } catch (Dali::DaliException e) {
89655       {
89656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89657       };
89658     } catch (...) {
89659       {
89660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89661       };
89662     }
89663   }
89664
89665   jresult = (void *)result;
89666   return jresult;
89667 }
89668
89669
89670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89671   void * jresult ;
89672   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89673   Dali::Toolkit::PageTurnView *result = 0 ;
89674
89675   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89676   if (!arg1) {
89677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89678     return 0;
89679   }
89680   {
89681     try {
89682       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89683     } catch (std::out_of_range& e) {
89684       {
89685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89686       };
89687     } catch (std::exception& e) {
89688       {
89689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89690       };
89691     } catch (Dali::DaliException e) {
89692       {
89693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89694       };
89695     } catch (...) {
89696       {
89697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89698       };
89699     }
89700   }
89701
89702   jresult = (void *)result;
89703   return jresult;
89704 }
89705
89706
89707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89708   void * jresult ;
89709   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89710   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89711   Dali::Toolkit::PageTurnView *result = 0 ;
89712
89713   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89714   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89715   if (!arg2) {
89716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89717     return 0;
89718   }
89719   {
89720     try {
89721       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89722     } catch (std::out_of_range& e) {
89723       {
89724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89725       };
89726     } catch (std::exception& e) {
89727       {
89728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89729       };
89730     } catch (Dali::DaliException e) {
89731       {
89732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89733       };
89734     } catch (...) {
89735       {
89736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89737       };
89738     }
89739   }
89740
89741   jresult = (void *)result;
89742   return jresult;
89743 }
89744
89745
89746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89747   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89748
89749   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89750   {
89751     try {
89752       delete arg1;
89753     } catch (std::out_of_range& e) {
89754       {
89755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89756       };
89757     } catch (std::exception& e) {
89758       {
89759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89760       };
89761     } catch (Dali::DaliException e) {
89762       {
89763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89764       };
89765     } catch (...) {
89766       {
89767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89768       };
89769     }
89770   }
89771
89772 }
89773
89774
89775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89776   void * jresult ;
89777   Dali::BaseHandle arg1 ;
89778   Dali::BaseHandle *argp1 ;
89779   Dali::Toolkit::PageTurnView result;
89780
89781   argp1 = (Dali::BaseHandle *)jarg1;
89782   if (!argp1) {
89783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89784     return 0;
89785   }
89786   arg1 = *argp1;
89787   {
89788     try {
89789       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89790     } catch (std::out_of_range& e) {
89791       {
89792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89793       };
89794     } catch (std::exception& e) {
89795       {
89796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89797       };
89798     } catch (Dali::DaliException e) {
89799       {
89800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89801       };
89802     } catch (...) {
89803       {
89804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89805       };
89806     }
89807   }
89808
89809   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89810   return jresult;
89811 }
89812
89813
89814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89815   void * jresult ;
89816   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89817   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89818
89819   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89820   {
89821     try {
89822       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89823     } catch (std::out_of_range& e) {
89824       {
89825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89826       };
89827     } catch (std::exception& e) {
89828       {
89829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89830       };
89831     } catch (Dali::DaliException e) {
89832       {
89833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89834       };
89835     } catch (...) {
89836       {
89837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89838       };
89839     }
89840   }
89841
89842   jresult = (void *)result;
89843   return jresult;
89844 }
89845
89846
89847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89848   void * jresult ;
89849   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89850   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89851
89852   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89853   {
89854     try {
89855       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89856     } catch (std::out_of_range& e) {
89857       {
89858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89859       };
89860     } catch (std::exception& e) {
89861       {
89862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89863       };
89864     } catch (Dali::DaliException e) {
89865       {
89866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89867       };
89868     } catch (...) {
89869       {
89870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89871       };
89872     }
89873   }
89874
89875   jresult = (void *)result;
89876   return jresult;
89877 }
89878
89879
89880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89881   void * jresult ;
89882   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89883   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89884
89885   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89886   {
89887     try {
89888       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89889     } catch (std::out_of_range& e) {
89890       {
89891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89892       };
89893     } catch (std::exception& e) {
89894       {
89895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89896       };
89897     } catch (Dali::DaliException e) {
89898       {
89899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89900       };
89901     } catch (...) {
89902       {
89903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89904       };
89905     }
89906   }
89907
89908   jresult = (void *)result;
89909   return jresult;
89910 }
89911
89912
89913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89914   void * jresult ;
89915   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89916   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89917
89918   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89919   {
89920     try {
89921       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89922     } catch (std::out_of_range& e) {
89923       {
89924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89925       };
89926     } catch (std::exception& e) {
89927       {
89928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89929       };
89930     } catch (Dali::DaliException e) {
89931       {
89932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89933       };
89934     } catch (...) {
89935       {
89936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89937       };
89938     }
89939   }
89940
89941   jresult = (void *)result;
89942   return jresult;
89943 }
89944
89945
89946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89947   void * jresult ;
89948   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89949
89950   {
89951     try {
89952       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89953     } catch (std::out_of_range& e) {
89954       {
89955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89956       };
89957     } catch (std::exception& e) {
89958       {
89959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89960       };
89961     } catch (Dali::DaliException e) {
89962       {
89963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89964       };
89965     } catch (...) {
89966       {
89967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89968       };
89969     }
89970   }
89971
89972   jresult = (void *)result;
89973   return jresult;
89974 }
89975
89976
89977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89978   void * jresult ;
89979   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89980   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89981
89982   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89983   if (!arg1) {
89984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89985     return 0;
89986   }
89987   {
89988     try {
89989       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89990     } catch (std::out_of_range& e) {
89991       {
89992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89993       };
89994     } catch (std::exception& e) {
89995       {
89996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89997       };
89998     } catch (Dali::DaliException e) {
89999       {
90000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90001       };
90002     } catch (...) {
90003       {
90004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90005       };
90006     }
90007   }
90008
90009   jresult = (void *)result;
90010   return jresult;
90011 }
90012
90013
90014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90015   void * jresult ;
90016   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90017   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90018   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90019
90020   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90021   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90022   if (!arg2) {
90023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90024     return 0;
90025   }
90026   {
90027     try {
90028       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90029     } catch (std::out_of_range& e) {
90030       {
90031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90032       };
90033     } catch (std::exception& e) {
90034       {
90035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90036       };
90037     } catch (Dali::DaliException e) {
90038       {
90039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90040       };
90041     } catch (...) {
90042       {
90043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90044       };
90045     }
90046   }
90047
90048   jresult = (void *)result;
90049   return jresult;
90050 }
90051
90052
90053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90054   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90055
90056   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90057   {
90058     try {
90059       delete arg1;
90060     } catch (std::out_of_range& e) {
90061       {
90062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90063       };
90064     } catch (std::exception& e) {
90065       {
90066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90067       };
90068     } catch (Dali::DaliException e) {
90069       {
90070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90071       };
90072     } catch (...) {
90073       {
90074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90075       };
90076     }
90077   }
90078
90079 }
90080
90081
90082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90083   void * jresult ;
90084   Dali::Toolkit::PageFactory *arg1 = 0 ;
90085   Dali::Vector2 *arg2 = 0 ;
90086   Dali::Toolkit::PageTurnLandscapeView result;
90087
90088   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90089   if (!arg1) {
90090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90091     return 0;
90092   }
90093   arg2 = (Dali::Vector2 *)jarg2;
90094   if (!arg2) {
90095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90096     return 0;
90097   }
90098   {
90099     try {
90100       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90101     } catch (std::out_of_range& e) {
90102       {
90103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90104       };
90105     } catch (std::exception& e) {
90106       {
90107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90108       };
90109     } catch (Dali::DaliException e) {
90110       {
90111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90112       };
90113     } catch (...) {
90114       {
90115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90116       };
90117     }
90118   }
90119
90120   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90121   return jresult;
90122 }
90123
90124
90125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90126   void * jresult ;
90127   Dali::BaseHandle arg1 ;
90128   Dali::BaseHandle *argp1 ;
90129   Dali::Toolkit::PageTurnLandscapeView result;
90130
90131   argp1 = (Dali::BaseHandle *)jarg1;
90132   if (!argp1) {
90133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90134     return 0;
90135   }
90136   arg1 = *argp1;
90137   {
90138     try {
90139       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90140     } catch (std::out_of_range& e) {
90141       {
90142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90143       };
90144     } catch (std::exception& e) {
90145       {
90146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90147       };
90148     } catch (Dali::DaliException e) {
90149       {
90150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90151       };
90152     } catch (...) {
90153       {
90154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90155       };
90156     }
90157   }
90158
90159   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90160   return jresult;
90161 }
90162
90163
90164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90165   void * jresult ;
90166   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90167
90168   {
90169     try {
90170       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90171     } catch (std::out_of_range& e) {
90172       {
90173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90174       };
90175     } catch (std::exception& e) {
90176       {
90177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90178       };
90179     } catch (Dali::DaliException e) {
90180       {
90181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90182       };
90183     } catch (...) {
90184       {
90185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90186       };
90187     }
90188   }
90189
90190   jresult = (void *)result;
90191   return jresult;
90192 }
90193
90194
90195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90196   void * jresult ;
90197   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90198   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90199
90200   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90201   if (!arg1) {
90202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90203     return 0;
90204   }
90205   {
90206     try {
90207       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90208     } catch (std::out_of_range& e) {
90209       {
90210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90211       };
90212     } catch (std::exception& e) {
90213       {
90214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90215       };
90216     } catch (Dali::DaliException e) {
90217       {
90218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90219       };
90220     } catch (...) {
90221       {
90222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90223       };
90224     }
90225   }
90226
90227   jresult = (void *)result;
90228   return jresult;
90229 }
90230
90231
90232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90233   void * jresult ;
90234   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90235   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90236   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90237
90238   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90239   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90240   if (!arg2) {
90241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90242     return 0;
90243   }
90244   {
90245     try {
90246       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90247     } catch (std::out_of_range& e) {
90248       {
90249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90250       };
90251     } catch (std::exception& e) {
90252       {
90253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90254       };
90255     } catch (Dali::DaliException e) {
90256       {
90257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90258       };
90259     } catch (...) {
90260       {
90261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90262       };
90263     }
90264   }
90265
90266   jresult = (void *)result;
90267   return jresult;
90268 }
90269
90270
90271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90272   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90273
90274   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90275   {
90276     try {
90277       delete arg1;
90278     } catch (std::out_of_range& e) {
90279       {
90280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90281       };
90282     } catch (std::exception& e) {
90283       {
90284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90285       };
90286     } catch (Dali::DaliException e) {
90287       {
90288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90289       };
90290     } catch (...) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90293       };
90294     }
90295   }
90296
90297 }
90298
90299
90300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90301   void * jresult ;
90302   Dali::Toolkit::PageFactory *arg1 = 0 ;
90303   Dali::Vector2 *arg2 = 0 ;
90304   Dali::Toolkit::PageTurnPortraitView result;
90305
90306   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90307   if (!arg1) {
90308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90309     return 0;
90310   }
90311   arg2 = (Dali::Vector2 *)jarg2;
90312   if (!arg2) {
90313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90314     return 0;
90315   }
90316   {
90317     try {
90318       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90319     } catch (std::out_of_range& e) {
90320       {
90321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90322       };
90323     } catch (std::exception& e) {
90324       {
90325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90326       };
90327     } catch (Dali::DaliException e) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90330       };
90331     } catch (...) {
90332       {
90333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90334       };
90335     }
90336   }
90337
90338   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90339   return jresult;
90340 }
90341
90342
90343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90344   void * jresult ;
90345   Dali::BaseHandle arg1 ;
90346   Dali::BaseHandle *argp1 ;
90347   Dali::Toolkit::PageTurnPortraitView result;
90348
90349   argp1 = (Dali::BaseHandle *)jarg1;
90350   if (!argp1) {
90351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90352     return 0;
90353   }
90354   arg1 = *argp1;
90355   {
90356     try {
90357       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90358     } catch (std::out_of_range& e) {
90359       {
90360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90361       };
90362     } catch (std::exception& e) {
90363       {
90364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90365       };
90366     } catch (Dali::DaliException e) {
90367       {
90368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90369       };
90370     } catch (...) {
90371       {
90372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90373       };
90374     }
90375   }
90376
90377   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90378   return jresult;
90379 }
90380
90381
90382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90383   int jresult ;
90384   int result;
90385
90386   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90387   jresult = (int)result;
90388   return jresult;
90389 }
90390
90391
90392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90393   int jresult ;
90394   int result;
90395
90396   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90397   jresult = (int)result;
90398   return jresult;
90399 }
90400
90401
90402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90403   int jresult ;
90404   int result;
90405
90406   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90407   jresult = (int)result;
90408   return jresult;
90409 }
90410
90411
90412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90413   void * jresult ;
90414   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90415
90416   {
90417     try {
90418       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90419     } catch (std::out_of_range& e) {
90420       {
90421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90422       };
90423     } catch (std::exception& e) {
90424       {
90425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90426       };
90427     } catch (Dali::DaliException e) {
90428       {
90429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90430       };
90431     } catch (...) {
90432       {
90433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90434       };
90435     }
90436   }
90437
90438   jresult = (void *)result;
90439   return jresult;
90440 }
90441
90442
90443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90444   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90445
90446   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90447   {
90448     try {
90449       delete arg1;
90450     } catch (std::out_of_range& e) {
90451       {
90452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90453       };
90454     } catch (std::exception& e) {
90455       {
90456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90457       };
90458     } catch (Dali::DaliException e) {
90459       {
90460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90461       };
90462     } catch (...) {
90463       {
90464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90465       };
90466     }
90467   }
90468
90469 }
90470
90471
90472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90473   void * jresult ;
90474   Dali::Toolkit::ToggleButton *result = 0 ;
90475
90476   {
90477     try {
90478       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90479     } catch (std::out_of_range& e) {
90480       {
90481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90482       };
90483     } catch (std::exception& e) {
90484       {
90485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90486       };
90487     } catch (Dali::DaliException e) {
90488       {
90489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90490       };
90491     } catch (...) {
90492       {
90493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90494       };
90495     }
90496   }
90497
90498   jresult = (void *)result;
90499   return jresult;
90500 }
90501
90502
90503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90504   void * jresult ;
90505   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90506   Dali::Toolkit::ToggleButton *result = 0 ;
90507
90508   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90509   if (!arg1) {
90510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90511     return 0;
90512   }
90513   {
90514     try {
90515       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90516     } catch (std::out_of_range& e) {
90517       {
90518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90519       };
90520     } catch (std::exception& e) {
90521       {
90522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90523       };
90524     } catch (Dali::DaliException e) {
90525       {
90526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90527       };
90528     } catch (...) {
90529       {
90530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90531       };
90532     }
90533   }
90534
90535   jresult = (void *)result;
90536   return jresult;
90537 }
90538
90539
90540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90541   void * jresult ;
90542   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90543   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90544   Dali::Toolkit::ToggleButton *result = 0 ;
90545
90546   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90547   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90548   if (!arg2) {
90549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90550     return 0;
90551   }
90552   {
90553     try {
90554       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90555     } catch (std::out_of_range& e) {
90556       {
90557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90558       };
90559     } catch (std::exception& e) {
90560       {
90561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90562       };
90563     } catch (Dali::DaliException e) {
90564       {
90565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90566       };
90567     } catch (...) {
90568       {
90569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90570       };
90571     }
90572   }
90573
90574   jresult = (void *)result;
90575   return jresult;
90576 }
90577
90578
90579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90580   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90581
90582   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90583   {
90584     try {
90585       delete arg1;
90586     } catch (std::out_of_range& e) {
90587       {
90588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90589       };
90590     } catch (std::exception& e) {
90591       {
90592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90593       };
90594     } catch (Dali::DaliException e) {
90595       {
90596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90597       };
90598     } catch (...) {
90599       {
90600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90601       };
90602     }
90603   }
90604
90605 }
90606
90607
90608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90609   void * jresult ;
90610   Dali::Toolkit::ToggleButton result;
90611
90612   {
90613     try {
90614       result = Dali::Toolkit::ToggleButton::New();
90615     } catch (std::out_of_range& e) {
90616       {
90617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90618       };
90619     } catch (std::exception& e) {
90620       {
90621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90622       };
90623     } catch (Dali::DaliException e) {
90624       {
90625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90626       };
90627     } catch (...) {
90628       {
90629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90630       };
90631     }
90632   }
90633
90634   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90635   return jresult;
90636 }
90637
90638
90639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90640   void * jresult ;
90641   Dali::BaseHandle arg1 ;
90642   Dali::BaseHandle *argp1 ;
90643   Dali::Toolkit::ToggleButton result;
90644
90645   argp1 = (Dali::BaseHandle *)jarg1;
90646   if (!argp1) {
90647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90648     return 0;
90649   }
90650   arg1 = *argp1;
90651   {
90652     try {
90653       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90654     } catch (std::out_of_range& e) {
90655       {
90656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90657       };
90658     } catch (std::exception& e) {
90659       {
90660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90661       };
90662     } catch (Dali::DaliException e) {
90663       {
90664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90665       };
90666     } catch (...) {
90667       {
90668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90669       };
90670     }
90671   }
90672
90673   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90674   return jresult;
90675 }
90676
90677
90678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90679   void * jresult ;
90680   Dali::Toolkit::Visual::Base *result = 0 ;
90681
90682   {
90683     try {
90684       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90685     } catch (std::out_of_range& e) {
90686       {
90687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90688       };
90689     } catch (std::exception& e) {
90690       {
90691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90692       };
90693     } catch (Dali::DaliException e) {
90694       {
90695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90696       };
90697     } catch (...) {
90698       {
90699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90700       };
90701     }
90702   }
90703
90704   jresult = (void *)result;
90705   return jresult;
90706 }
90707
90708
90709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90710   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90711
90712   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90713   {
90714     try {
90715       delete arg1;
90716     } catch (std::out_of_range& e) {
90717       {
90718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90719       };
90720     } catch (std::exception& e) {
90721       {
90722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90723       };
90724     } catch (Dali::DaliException e) {
90725       {
90726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90727       };
90728     } catch (...) {
90729       {
90730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90731       };
90732     }
90733   }
90734
90735 }
90736
90737
90738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90739   void * jresult ;
90740   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90741   Dali::Toolkit::Visual::Base *result = 0 ;
90742
90743   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90744   if (!arg1) {
90745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90746     return 0;
90747   }
90748   {
90749     try {
90750       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90751     } catch (std::out_of_range& e) {
90752       {
90753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90754       };
90755     } catch (std::exception& e) {
90756       {
90757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90758       };
90759     } catch (Dali::DaliException e) {
90760       {
90761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90762       };
90763     } catch (...) {
90764       {
90765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90766       };
90767     }
90768   }
90769
90770   jresult = (void *)result;
90771   return jresult;
90772 }
90773
90774
90775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90776   void * jresult ;
90777   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90778   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90779   Dali::Toolkit::Visual::Base *result = 0 ;
90780
90781   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90782   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90783   if (!arg2) {
90784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90785     return 0;
90786   }
90787   {
90788     try {
90789       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90790     } catch (std::out_of_range& e) {
90791       {
90792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90793       };
90794     } catch (std::exception& e) {
90795       {
90796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90797       };
90798     } catch (Dali::DaliException e) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90801       };
90802     } catch (...) {
90803       {
90804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90805       };
90806     }
90807   }
90808
90809   jresult = (void *)result;
90810   return jresult;
90811 }
90812
90813
90814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90815   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90816   std::string *arg2 = 0 ;
90817
90818   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90819   if (!jarg2) {
90820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90821     return ;
90822   }
90823   std::string arg2_str(jarg2);
90824   arg2 = &arg2_str;
90825   {
90826     try {
90827       (arg1)->SetName((std::string const &)*arg2);
90828     } catch (std::out_of_range& e) {
90829       {
90830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90831       };
90832     } catch (std::exception& e) {
90833       {
90834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90835       };
90836     } catch (Dali::DaliException e) {
90837       {
90838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90839       };
90840     } catch (...) {
90841       {
90842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90843       };
90844     }
90845   }
90846
90847
90848   //argout typemap for const std::string&
90849
90850 }
90851
90852
90853 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90854   char * jresult ;
90855   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90856   std::string *result = 0 ;
90857
90858   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90859   {
90860     try {
90861       result = (std::string *) &(arg1)->GetName();
90862     } catch (std::out_of_range& e) {
90863       {
90864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90865       };
90866     } catch (std::exception& e) {
90867       {
90868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90869       };
90870     } catch (Dali::DaliException e) {
90871       {
90872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90873       };
90874     } catch (...) {
90875       {
90876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90877       };
90878     }
90879   }
90880
90881   jresult = SWIG_csharp_string_callback(result->c_str());
90882   return jresult;
90883 }
90884
90885
90886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90887   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90888   Dali::Property::Map *arg2 = 0 ;
90889   Dali::Size arg3 ;
90890   Dali::Size *argp3 ;
90891
90892   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90893   arg2 = (Dali::Property::Map *)jarg2;
90894   if (!arg2) {
90895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90896     return ;
90897   }
90898   argp3 = (Dali::Size *)jarg3;
90899   if (!argp3) {
90900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90901     return ;
90902   }
90903   arg3 = *argp3;
90904   {
90905     try {
90906       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90907     } catch (std::out_of_range& e) {
90908       {
90909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90910       };
90911     } catch (std::exception& e) {
90912       {
90913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90914       };
90915     } catch (Dali::DaliException e) {
90916       {
90917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90918       };
90919     } catch (...) {
90920       {
90921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90922       };
90923     }
90924   }
90925
90926 }
90927
90928
90929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90930   float jresult ;
90931   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90932   float arg2 ;
90933   float result;
90934
90935   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90936   arg2 = (float)jarg2;
90937   {
90938     try {
90939       result = (float)(arg1)->GetHeightForWidth(arg2);
90940     } catch (std::out_of_range& e) {
90941       {
90942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90943       };
90944     } catch (std::exception& e) {
90945       {
90946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90947       };
90948     } catch (Dali::DaliException e) {
90949       {
90950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90951       };
90952     } catch (...) {
90953       {
90954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90955       };
90956     }
90957   }
90958
90959   jresult = result;
90960   return jresult;
90961 }
90962
90963
90964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90965   float jresult ;
90966   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90967   float arg2 ;
90968   float result;
90969
90970   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90971   arg2 = (float)jarg2;
90972   {
90973     try {
90974       result = (float)(arg1)->GetWidthForHeight(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 = result;
90995   return jresult;
90996 }
90997
90998
90999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91000   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91001   Dali::Vector2 *arg2 = 0 ;
91002
91003   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91004   arg2 = (Dali::Vector2 *)jarg2;
91005   if (!arg2) {
91006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91007     return ;
91008   }
91009   {
91010     try {
91011       (arg1)->GetNaturalSize(*arg2);
91012     } catch (std::out_of_range& e) {
91013       {
91014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91015       };
91016     } catch (std::exception& e) {
91017       {
91018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91019       };
91020     } catch (Dali::DaliException e) {
91021       {
91022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91023       };
91024     } catch (...) {
91025       {
91026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91027       };
91028     }
91029   }
91030
91031 }
91032
91033
91034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91035   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91036   float arg2 ;
91037
91038   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91039   arg2 = (int)jarg2;
91040   {
91041     try {
91042       (arg1)->SetDepthIndex(arg2);
91043     } catch (std::out_of_range& e) {
91044       {
91045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91046       };
91047     } catch (std::exception& e) {
91048       {
91049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91050       };
91051     } catch (Dali::DaliException e) {
91052       {
91053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91054       };
91055     } catch (...) {
91056       {
91057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91058       };
91059     }
91060   }
91061
91062 }
91063
91064
91065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91066   int jresult ;
91067   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91068   int result;
91069
91070   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91071   {
91072     try {
91073       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91074     } catch (std::out_of_range& e) {
91075       {
91076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91077       };
91078     } catch (std::exception& e) {
91079       {
91080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91081       };
91082     } catch (Dali::DaliException e) {
91083       {
91084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91085       };
91086     } catch (...) {
91087       {
91088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91089       };
91090     }
91091   }
91092
91093   jresult = result;
91094   return jresult;
91095 }
91096
91097
91098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91099   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91100   Dali::Property::Map *arg2 = 0 ;
91101
91102   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91103   arg2 = (Dali::Property::Map *)jarg2;
91104   if (!arg2) {
91105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91106     return ;
91107   }
91108   {
91109     try {
91110       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91111     } catch (std::out_of_range& e) {
91112       {
91113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91114       };
91115     } catch (std::exception& e) {
91116       {
91117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91118       };
91119     } catch (Dali::DaliException e) {
91120       {
91121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91122       };
91123     } catch (...) {
91124       {
91125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91126       };
91127     }
91128   }
91129
91130 }
91131
91132
91133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91134   void * jresult ;
91135   Dali::Toolkit::VisualFactory result;
91136
91137   {
91138     try {
91139       result = Dali::Toolkit::VisualFactory::Get();
91140     } catch (std::out_of_range& e) {
91141       {
91142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91143       };
91144     } catch (std::exception& e) {
91145       {
91146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91147       };
91148     } catch (Dali::DaliException e) {
91149       {
91150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91151       };
91152     } catch (...) {
91153       {
91154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91155       };
91156     }
91157   }
91158
91159   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91160   return jresult;
91161 }
91162
91163
91164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91165   void * jresult ;
91166   Dali::Toolkit::VisualFactory *result = 0 ;
91167
91168   {
91169     try {
91170       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91171     } catch (std::out_of_range& e) {
91172       {
91173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91174       };
91175     } catch (std::exception& e) {
91176       {
91177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91178       };
91179     } catch (Dali::DaliException e) {
91180       {
91181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91182       };
91183     } catch (...) {
91184       {
91185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91186       };
91187     }
91188   }
91189
91190   jresult = (void *)result;
91191   return jresult;
91192 }
91193
91194
91195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91196   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91197
91198   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91199   {
91200     try {
91201       delete arg1;
91202     } catch (std::out_of_range& e) {
91203       {
91204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91205       };
91206     } catch (std::exception& e) {
91207       {
91208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91209       };
91210     } catch (Dali::DaliException e) {
91211       {
91212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91213       };
91214     } catch (...) {
91215       {
91216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91217       };
91218     }
91219   }
91220
91221 }
91222
91223
91224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91225   void * jresult ;
91226   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91227   Dali::Toolkit::VisualFactory *result = 0 ;
91228
91229   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91230   if (!arg1) {
91231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91232     return 0;
91233   }
91234   {
91235     try {
91236       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91237     } catch (std::out_of_range& e) {
91238       {
91239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91240       };
91241     } catch (std::exception& e) {
91242       {
91243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91244       };
91245     } catch (Dali::DaliException e) {
91246       {
91247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91248       };
91249     } catch (...) {
91250       {
91251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91252       };
91253     }
91254   }
91255
91256   jresult = (void *)result;
91257   return jresult;
91258 }
91259
91260
91261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91262   void * jresult ;
91263   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91264   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91265   Dali::Toolkit::VisualFactory *result = 0 ;
91266
91267   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91268   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91269   if (!arg2) {
91270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91271     return 0;
91272   }
91273   {
91274     try {
91275       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91276     } catch (std::out_of_range& e) {
91277       {
91278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91279       };
91280     } catch (std::exception& e) {
91281       {
91282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91283       };
91284     } catch (Dali::DaliException e) {
91285       {
91286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91287       };
91288     } catch (...) {
91289       {
91290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91291       };
91292     }
91293   }
91294
91295   jresult = (void *)result;
91296   return jresult;
91297 }
91298
91299
91300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91301   void * jresult ;
91302   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91303   Dali::Property::Map *arg2 = 0 ;
91304   Dali::Toolkit::Visual::Base result;
91305
91306   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91307   arg2 = (Dali::Property::Map *)jarg2;
91308   if (!arg2) {
91309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91310     return 0;
91311   }
91312   {
91313     try {
91314       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91315     } catch (std::out_of_range& e) {
91316       {
91317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91318       };
91319     } catch (std::exception& e) {
91320       {
91321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91322       };
91323     } catch (Dali::DaliException e) {
91324       {
91325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91326       };
91327     } catch (...) {
91328       {
91329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91330       };
91331     }
91332   }
91333
91334   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91335   return jresult;
91336 }
91337
91338
91339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91340   void * jresult ;
91341   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91342   Dali::Image *arg2 = 0 ;
91343   Dali::Toolkit::Visual::Base result;
91344
91345   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91346   arg2 = (Dali::Image *)jarg2;
91347   if (!arg2) {
91348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91349     return 0;
91350   }
91351   {
91352     try {
91353       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91354     } catch (std::out_of_range& e) {
91355       {
91356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91357       };
91358     } catch (std::exception& e) {
91359       {
91360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91361       };
91362     } catch (Dali::DaliException e) {
91363       {
91364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91365       };
91366     } catch (...) {
91367       {
91368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91369       };
91370     }
91371   }
91372
91373   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91374   return jresult;
91375 }
91376
91377
91378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91379   void * jresult ;
91380   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91381   std::string *arg2 = 0 ;
91382   Dali::ImageDimensions arg3 ;
91383   Dali::ImageDimensions *argp3 ;
91384   Dali::Toolkit::Visual::Base result;
91385
91386   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91387   if (!jarg2) {
91388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91389     return 0;
91390   }
91391   std::string arg2_str(jarg2);
91392   arg2 = &arg2_str;
91393   argp3 = (Dali::ImageDimensions *)jarg3;
91394   if (!argp3) {
91395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91396     return 0;
91397   }
91398   arg3 = *argp3;
91399   {
91400     try {
91401       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91402     } catch (std::out_of_range& e) {
91403       {
91404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91405       };
91406     } catch (std::exception& e) {
91407       {
91408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91409       };
91410     } catch (Dali::DaliException e) {
91411       {
91412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91413       };
91414     } catch (...) {
91415       {
91416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91417       };
91418     }
91419   }
91420
91421   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91422
91423   //argout typemap for const std::string&
91424
91425   return jresult;
91426 }
91427
91428
91429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91430   void * jresult ;
91431   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91432
91433   {
91434     try {
91435       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91436     } catch (std::out_of_range& e) {
91437       {
91438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91439       };
91440     } catch (std::exception& e) {
91441       {
91442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91443       };
91444     } catch (Dali::DaliException e) {
91445       {
91446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91447       };
91448     } catch (...) {
91449       {
91450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91451       };
91452     }
91453   }
91454
91455   jresult = (void *)result;
91456   return jresult;
91457 }
91458
91459
91460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91461   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91462
91463   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91464   {
91465     try {
91466       delete arg1;
91467     } catch (std::out_of_range& e) {
91468       {
91469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91470       };
91471     } catch (std::exception& e) {
91472       {
91473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91474       };
91475     } catch (Dali::DaliException e) {
91476       {
91477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91478       };
91479     } catch (...) {
91480       {
91481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91482       };
91483     }
91484   }
91485
91486 }
91487
91488
91489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91490   void * jresult ;
91491   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91492   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91493
91494   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91495   if (!arg1) {
91496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91497     return 0;
91498   }
91499   {
91500     try {
91501       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91502     } catch (std::out_of_range& e) {
91503       {
91504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91505       };
91506     } catch (std::exception& e) {
91507       {
91508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91509       };
91510     } catch (Dali::DaliException e) {
91511       {
91512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91513       };
91514     } catch (...) {
91515       {
91516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91517       };
91518     }
91519   }
91520
91521   jresult = (void *)result;
91522   return jresult;
91523 }
91524
91525
91526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91527   void * jresult ;
91528   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91529   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91530   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91531
91532   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91533   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91534   if (!arg2) {
91535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91536     return 0;
91537   }
91538   {
91539     try {
91540       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91541     } catch (std::out_of_range& e) {
91542       {
91543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91544       };
91545     } catch (std::exception& e) {
91546       {
91547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91548       };
91549     } catch (Dali::DaliException e) {
91550       {
91551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91552       };
91553     } catch (...) {
91554       {
91555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91556       };
91557     }
91558   }
91559
91560   jresult = (void *)result;
91561   return jresult;
91562 }
91563
91564
91565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91566   void * jresult ;
91567   Dali::Toolkit::AsyncImageLoader result;
91568
91569   {
91570     try {
91571       result = Dali::Toolkit::AsyncImageLoader::New();
91572     } catch (std::out_of_range& e) {
91573       {
91574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91575       };
91576     } catch (std::exception& e) {
91577       {
91578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91579       };
91580     } catch (Dali::DaliException e) {
91581       {
91582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91583       };
91584     } catch (...) {
91585       {
91586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91587       };
91588     }
91589   }
91590
91591   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91592   return jresult;
91593 }
91594
91595
91596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91597   void * jresult ;
91598   Dali::BaseHandle arg1 ;
91599   Dali::BaseHandle *argp1 ;
91600   Dali::Toolkit::AsyncImageLoader result;
91601
91602   argp1 = (Dali::BaseHandle *)jarg1;
91603   if (!argp1) {
91604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91605     return 0;
91606   }
91607   arg1 = *argp1;
91608   {
91609     try {
91610       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91611     } catch (std::out_of_range& e) {
91612       {
91613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91614       };
91615     } catch (std::exception& e) {
91616       {
91617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91618       };
91619     } catch (Dali::DaliException e) {
91620       {
91621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91622       };
91623     } catch (...) {
91624       {
91625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91626       };
91627     }
91628   }
91629
91630   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91631   return jresult;
91632 }
91633
91634
91635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91636   unsigned int jresult ;
91637   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91638   std::string *arg2 = 0 ;
91639   uint32_t result;
91640
91641   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91642   if (!jarg2) {
91643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91644     return 0;
91645   }
91646   std::string arg2_str(jarg2);
91647   arg2 = &arg2_str;
91648   {
91649     try {
91650       result = (arg1)->Load((std::string const &)*arg2);
91651     } catch (std::out_of_range& e) {
91652       {
91653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91654       };
91655     } catch (std::exception& e) {
91656       {
91657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91658       };
91659     } catch (Dali::DaliException e) {
91660       {
91661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91662       };
91663     } catch (...) {
91664       {
91665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91666       };
91667     }
91668   }
91669
91670   jresult = result;
91671
91672   //argout typemap for const std::string&
91673
91674   return jresult;
91675 }
91676
91677
91678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91679   unsigned int jresult ;
91680   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91681   std::string *arg2 = 0 ;
91682   Dali::ImageDimensions arg3 ;
91683   Dali::ImageDimensions *argp3 ;
91684   uint32_t result;
91685
91686   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91687   if (!jarg2) {
91688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91689     return 0;
91690   }
91691   std::string arg2_str(jarg2);
91692   arg2 = &arg2_str;
91693   argp3 = (Dali::ImageDimensions *)jarg3;
91694   if (!argp3) {
91695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91696     return 0;
91697   }
91698   arg3 = *argp3;
91699   {
91700     try {
91701       result = (arg1)->Load((std::string const &)*arg2,arg3);
91702     } catch (std::out_of_range& e) {
91703       {
91704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91705       };
91706     } catch (std::exception& e) {
91707       {
91708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91709       };
91710     } catch (Dali::DaliException e) {
91711       {
91712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91713       };
91714     } catch (...) {
91715       {
91716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91717       };
91718     }
91719   }
91720
91721   jresult = result;
91722
91723   //argout typemap for const std::string&
91724
91725   return jresult;
91726 }
91727
91728
91729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91730   unsigned int jresult ;
91731   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91732   std::string *arg2 = 0 ;
91733   Dali::ImageDimensions arg3 ;
91734   Dali::FittingMode::Type arg4 ;
91735   Dali::SamplingMode::Type arg5 ;
91736   bool arg6 ;
91737   Dali::ImageDimensions *argp3 ;
91738   uint32_t result;
91739
91740   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91741   if (!jarg2) {
91742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91743     return 0;
91744   }
91745   std::string arg2_str(jarg2);
91746   arg2 = &arg2_str;
91747   argp3 = (Dali::ImageDimensions *)jarg3;
91748   if (!argp3) {
91749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91750     return 0;
91751   }
91752   arg3 = *argp3;
91753   arg4 = (Dali::FittingMode::Type)jarg4;
91754   arg5 = (Dali::SamplingMode::Type)jarg5;
91755   arg6 = jarg6 ? true : false;
91756   {
91757     try {
91758       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91759     } catch (std::out_of_range& e) {
91760       {
91761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91762       };
91763     } catch (std::exception& e) {
91764       {
91765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91766       };
91767     } catch (Dali::DaliException e) {
91768       {
91769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91770       };
91771     } catch (...) {
91772       {
91773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91774       };
91775     }
91776   }
91777
91778   jresult = result;
91779
91780   //argout typemap for const std::string&
91781
91782   return jresult;
91783 }
91784
91785
91786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91787   unsigned int jresult ;
91788   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91789   uint32_t arg2 ;
91790   bool result;
91791
91792   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91793   arg2 = (uint32_t)jarg2;
91794   {
91795     try {
91796       result = (bool)(arg1)->Cancel(arg2);
91797     } catch (std::out_of_range& e) {
91798       {
91799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91800       };
91801     } catch (std::exception& e) {
91802       {
91803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91804       };
91805     } catch (Dali::DaliException e) {
91806       {
91807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91808       };
91809     } catch (...) {
91810       {
91811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91812       };
91813     }
91814   }
91815
91816   jresult = result;
91817   return jresult;
91818 }
91819
91820
91821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91822   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91823
91824   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91825   {
91826     try {
91827       (arg1)->CancelAll();
91828     } catch (std::out_of_range& e) {
91829       {
91830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91831       };
91832     } catch (std::exception& e) {
91833       {
91834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91835       };
91836     } catch (Dali::DaliException e) {
91837       {
91838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91839       };
91840     } catch (...) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91843       };
91844     }
91845   }
91846
91847 }
91848
91849
91850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91851   void * jresult ;
91852   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91853   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91854
91855   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91856   {
91857     try {
91858       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91859     } catch (std::out_of_range& e) {
91860       {
91861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91862       };
91863     } catch (std::exception& e) {
91864       {
91865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91866       };
91867     } catch (Dali::DaliException e) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91870       };
91871     } catch (...) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91874       };
91875     }
91876   }
91877
91878   jresult = (void *)result;
91879   return jresult;
91880 }
91881
91882
91883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91884   void * jresult ;
91885   std::string *arg1 = 0 ;
91886   Dali::PixelData result;
91887
91888   if (!jarg1) {
91889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91890     return 0;
91891   }
91892   std::string arg1_str(jarg1);
91893   arg1 = &arg1_str;
91894   {
91895     try {
91896       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91897     } catch (std::out_of_range& e) {
91898       {
91899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91900       };
91901     } catch (std::exception& e) {
91902       {
91903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91904       };
91905     } catch (Dali::DaliException e) {
91906       {
91907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91908       };
91909     } catch (...) {
91910       {
91911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91912       };
91913     }
91914   }
91915
91916   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91917
91918   //argout typemap for const std::string&
91919
91920   return jresult;
91921 }
91922
91923
91924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91925   void * jresult ;
91926   std::string *arg1 = 0 ;
91927   Dali::ImageDimensions arg2 ;
91928   Dali::ImageDimensions *argp2 ;
91929   Dali::PixelData result;
91930
91931   if (!jarg1) {
91932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91933     return 0;
91934   }
91935   std::string arg1_str(jarg1);
91936   arg1 = &arg1_str;
91937   argp2 = (Dali::ImageDimensions *)jarg2;
91938   if (!argp2) {
91939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91940     return 0;
91941   }
91942   arg2 = *argp2;
91943   {
91944     try {
91945       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91946     } catch (std::out_of_range& e) {
91947       {
91948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91949       };
91950     } catch (std::exception& e) {
91951       {
91952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91953       };
91954     } catch (Dali::DaliException e) {
91955       {
91956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91957       };
91958     } catch (...) {
91959       {
91960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91961       };
91962     }
91963   }
91964
91965   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91966
91967   //argout typemap for const std::string&
91968
91969   return jresult;
91970 }
91971
91972
91973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91974   void * jresult ;
91975   std::string *arg1 = 0 ;
91976   Dali::ImageDimensions arg2 ;
91977   Dali::FittingMode::Type arg3 ;
91978   Dali::SamplingMode::Type arg4 ;
91979   bool arg5 ;
91980   Dali::ImageDimensions *argp2 ;
91981   Dali::PixelData result;
91982
91983   if (!jarg1) {
91984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91985     return 0;
91986   }
91987   std::string arg1_str(jarg1);
91988   arg1 = &arg1_str;
91989   argp2 = (Dali::ImageDimensions *)jarg2;
91990   if (!argp2) {
91991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91992     return 0;
91993   }
91994   arg2 = *argp2;
91995   arg3 = (Dali::FittingMode::Type)jarg3;
91996   arg4 = (Dali::SamplingMode::Type)jarg4;
91997   arg5 = jarg5 ? true : false;
91998   {
91999     try {
92000       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92001     } catch (std::out_of_range& e) {
92002       {
92003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92004       };
92005     } catch (std::exception& e) {
92006       {
92007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92008       };
92009     } catch (Dali::DaliException e) {
92010       {
92011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92012       };
92013     } catch (...) {
92014       {
92015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92016       };
92017     }
92018   }
92019
92020   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92021
92022   //argout typemap for const std::string&
92023
92024   return jresult;
92025 }
92026
92027
92028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92029   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92030
92031   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92032   {
92033     try {
92034       delete arg1;
92035     } catch (std::out_of_range& e) {
92036       {
92037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92038       };
92039     } catch (std::exception& e) {
92040       {
92041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92042       };
92043     } catch (Dali::DaliException e) {
92044       {
92045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92046       };
92047     } catch (...) {
92048       {
92049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92050       };
92051     }
92052   }
92053
92054 }
92055
92056
92057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92058   void * jresult ;
92059   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92060   Dali::Actor arg2 ;
92061   Dali::Actor arg3 ;
92062   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92063   Dali::Actor *argp2 ;
92064   Dali::Actor *argp3 ;
92065   Dali::Actor result;
92066
92067   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92068   argp2 = (Dali::Actor *)jarg2;
92069   if (!argp2) {
92070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92071     return 0;
92072   }
92073   arg2 = *argp2;
92074   argp3 = (Dali::Actor *)jarg3;
92075   if (!argp3) {
92076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92077     return 0;
92078   }
92079   arg3 = *argp3;
92080   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92081   {
92082     try {
92083       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92084     } catch (std::out_of_range& e) {
92085       {
92086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92087       };
92088     } catch (std::exception& e) {
92089       {
92090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92091       };
92092     } catch (Dali::DaliException e) {
92093       {
92094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92095       };
92096     } catch (...) {
92097       {
92098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92099       };
92100     }
92101   }
92102
92103   jresult = new Dali::Actor((const Dali::Actor &)result);
92104   return jresult;
92105 }
92106
92107
92108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92109   void * jresult ;
92110   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92111
92112   {
92113     try {
92114       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92115     } catch (std::out_of_range& e) {
92116       {
92117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92118       };
92119     } catch (std::exception& e) {
92120       {
92121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92122       };
92123     } catch (Dali::DaliException e) {
92124       {
92125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92126       };
92127     } catch (...) {
92128       {
92129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92130       };
92131     }
92132   }
92133
92134   jresult = (void *)result;
92135   return jresult;
92136 }
92137
92138
92139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92140   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92141   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92142   if (director) {
92143     director->swig_connect_director(callback0);
92144   }
92145 }
92146
92147
92148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92149   KeyboardFocusManager arg1 ;
92150   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92151   KeyboardFocusManager *argp1 ;
92152
92153   argp1 = (KeyboardFocusManager *)jarg1;
92154   if (!argp1) {
92155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92156     return ;
92157   }
92158   arg1 = *argp1;
92159   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92160   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
92161   {
92162     try {
92163       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92164     } catch (std::out_of_range& e) {
92165       {
92166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92167       };
92168     } catch (std::exception& e) {
92169       {
92170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92171       };
92172     } catch (Dali::DaliException e) {
92173       {
92174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92175       };
92176     } catch (...) {
92177       {
92178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92179       };
92180     }
92181   }
92182
92183 }
92184
92185
92186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92187   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92188
92189   arg1 = (std::vector< unsigned int > *)jarg1;
92190   {
92191     try {
92192       (arg1)->clear();
92193     } catch (std::out_of_range& e) {
92194       {
92195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92196       };
92197     } catch (std::exception& e) {
92198       {
92199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92200       };
92201     } catch (Dali::DaliException e) {
92202       {
92203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92204       };
92205     } catch (...) {
92206       {
92207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92208       };
92209     }
92210   }
92211
92212 }
92213
92214
92215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92216   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92217   unsigned int *arg2 = 0 ;
92218   unsigned int temp2 ;
92219
92220   arg1 = (std::vector< unsigned int > *)jarg1;
92221   temp2 = (unsigned int)jarg2;
92222   arg2 = &temp2;
92223   {
92224     try {
92225       (arg1)->push_back((unsigned int const &)*arg2);
92226     } catch (std::out_of_range& e) {
92227       {
92228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92229       };
92230     } catch (std::exception& e) {
92231       {
92232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92233       };
92234     } catch (Dali::DaliException e) {
92235       {
92236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92237       };
92238     } catch (...) {
92239       {
92240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92241       };
92242     }
92243   }
92244
92245 }
92246
92247
92248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92249   unsigned long jresult ;
92250   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92251   std::vector< unsigned int >::size_type result;
92252
92253   arg1 = (std::vector< unsigned int > *)jarg1;
92254   {
92255     try {
92256       result = ((std::vector< unsigned int > const *)arg1)->size();
92257     } catch (std::out_of_range& e) {
92258       {
92259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92260       };
92261     } catch (std::exception& e) {
92262       {
92263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92264       };
92265     } catch (Dali::DaliException e) {
92266       {
92267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92268       };
92269     } catch (...) {
92270       {
92271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92272       };
92273     }
92274   }
92275
92276   jresult = (unsigned long)result;
92277   return jresult;
92278 }
92279
92280
92281 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92282   unsigned long jresult ;
92283   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92284   std::vector< unsigned int >::size_type result;
92285
92286   arg1 = (std::vector< unsigned int > *)jarg1;
92287   {
92288     try {
92289       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92290     } catch (std::out_of_range& e) {
92291       {
92292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92293       };
92294     } catch (std::exception& e) {
92295       {
92296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92297       };
92298     } catch (Dali::DaliException e) {
92299       {
92300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92301       };
92302     } catch (...) {
92303       {
92304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92305       };
92306     }
92307   }
92308
92309   jresult = (unsigned long)result;
92310   return jresult;
92311 }
92312
92313
92314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92315   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92316   std::vector< unsigned int >::size_type arg2 ;
92317
92318   arg1 = (std::vector< unsigned int > *)jarg1;
92319   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92320   {
92321     try {
92322       (arg1)->reserve(arg2);
92323     } catch (std::out_of_range& e) {
92324       {
92325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92326       };
92327     } catch (std::exception& e) {
92328       {
92329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92330       };
92331     } catch (Dali::DaliException e) {
92332       {
92333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92334       };
92335     } catch (...) {
92336       {
92337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92338       };
92339     }
92340   }
92341
92342 }
92343
92344
92345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92346   void * jresult ;
92347   std::vector< unsigned int > *result = 0 ;
92348
92349   {
92350     try {
92351       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92352     } catch (std::out_of_range& e) {
92353       {
92354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92355       };
92356     } catch (std::exception& e) {
92357       {
92358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92359       };
92360     } catch (Dali::DaliException e) {
92361       {
92362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92363       };
92364     } catch (...) {
92365       {
92366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92367       };
92368     }
92369   }
92370
92371   jresult = (void *)result;
92372   return jresult;
92373 }
92374
92375
92376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92377   void * jresult ;
92378   std::vector< unsigned int > *arg1 = 0 ;
92379   std::vector< unsigned int > *result = 0 ;
92380
92381   arg1 = (std::vector< unsigned int > *)jarg1;
92382   if (!arg1) {
92383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92384     return 0;
92385   }
92386   {
92387     try {
92388       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92389     } catch (std::out_of_range& e) {
92390       {
92391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92392       };
92393     } catch (std::exception& e) {
92394       {
92395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92396       };
92397     } catch (Dali::DaliException e) {
92398       {
92399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92400       };
92401     } catch (...) {
92402       {
92403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92404       };
92405     }
92406   }
92407
92408   jresult = (void *)result;
92409   return jresult;
92410 }
92411
92412
92413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92414   void * jresult ;
92415   int arg1 ;
92416   std::vector< unsigned int > *result = 0 ;
92417
92418   arg1 = (int)jarg1;
92419   {
92420     try {
92421       try {
92422         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92423       }
92424       catch(std::out_of_range &_e) {
92425         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92426         return 0;
92427       }
92428
92429     } catch (std::out_of_range& e) {
92430       {
92431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92432       };
92433     } catch (std::exception& e) {
92434       {
92435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92436       };
92437     } catch (Dali::DaliException e) {
92438       {
92439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92440       };
92441     } catch (...) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92444       };
92445     }
92446   }
92447
92448   jresult = (void *)result;
92449   return jresult;
92450 }
92451
92452
92453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92454   unsigned int jresult ;
92455   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92456   int arg2 ;
92457   unsigned int result;
92458
92459   arg1 = (std::vector< unsigned int > *)jarg1;
92460   arg2 = (int)jarg2;
92461   {
92462     try {
92463       try {
92464         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92465       }
92466       catch(std::out_of_range &_e) {
92467         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92468         return 0;
92469       }
92470
92471     } catch (std::out_of_range& e) {
92472       {
92473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92474       };
92475     } catch (std::exception& e) {
92476       {
92477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92478       };
92479     } catch (Dali::DaliException e) {
92480       {
92481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92482       };
92483     } catch (...) {
92484       {
92485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92486       };
92487     }
92488   }
92489
92490   jresult = result;
92491   return jresult;
92492 }
92493
92494
92495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92496   unsigned int jresult ;
92497   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92498   int arg2 ;
92499   unsigned int *result = 0 ;
92500
92501   arg1 = (std::vector< unsigned int > *)jarg1;
92502   arg2 = (int)jarg2;
92503   {
92504     try {
92505       try {
92506         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92507       }
92508       catch(std::out_of_range &_e) {
92509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92510         return 0;
92511       }
92512
92513     } catch (std::out_of_range& e) {
92514       {
92515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92516       };
92517     } catch (std::exception& e) {
92518       {
92519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92520       };
92521     } catch (Dali::DaliException e) {
92522       {
92523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92524       };
92525     } catch (...) {
92526       {
92527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92528       };
92529     }
92530   }
92531
92532   jresult = *result;
92533   return jresult;
92534 }
92535
92536
92537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92538   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92539   int arg2 ;
92540   unsigned int *arg3 = 0 ;
92541   unsigned int temp3 ;
92542
92543   arg1 = (std::vector< unsigned int > *)jarg1;
92544   arg2 = (int)jarg2;
92545   temp3 = (unsigned int)jarg3;
92546   arg3 = &temp3;
92547   {
92548     try {
92549       try {
92550         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92551       }
92552       catch(std::out_of_range &_e) {
92553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92554         return ;
92555       }
92556
92557     } catch (std::out_of_range& e) {
92558       {
92559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92560       };
92561     } catch (std::exception& e) {
92562       {
92563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92564       };
92565     } catch (Dali::DaliException e) {
92566       {
92567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92568       };
92569     } catch (...) {
92570       {
92571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92572       };
92573     }
92574   }
92575
92576 }
92577
92578
92579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92580   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92581   std::vector< unsigned int > *arg2 = 0 ;
92582
92583   arg1 = (std::vector< unsigned int > *)jarg1;
92584   arg2 = (std::vector< unsigned int > *)jarg2;
92585   if (!arg2) {
92586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92587     return ;
92588   }
92589   {
92590     try {
92591       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92592     } catch (std::out_of_range& e) {
92593       {
92594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92595       };
92596     } catch (std::exception& e) {
92597       {
92598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92599       };
92600     } catch (Dali::DaliException e) {
92601       {
92602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92603       };
92604     } catch (...) {
92605       {
92606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92607       };
92608     }
92609   }
92610
92611 }
92612
92613
92614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92615   void * jresult ;
92616   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92617   int arg2 ;
92618   int arg3 ;
92619   std::vector< unsigned int > *result = 0 ;
92620
92621   arg1 = (std::vector< unsigned int > *)jarg1;
92622   arg2 = (int)jarg2;
92623   arg3 = (int)jarg3;
92624   {
92625     try {
92626       try {
92627         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92628       }
92629       catch(std::out_of_range &_e) {
92630         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92631         return 0;
92632       }
92633       catch(std::invalid_argument &_e) {
92634         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92635         return 0;
92636       }
92637
92638     } catch (std::out_of_range& e) {
92639       {
92640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92641       };
92642     } catch (std::exception& e) {
92643       {
92644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92645       };
92646     } catch (Dali::DaliException e) {
92647       {
92648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92649       };
92650     } catch (...) {
92651       {
92652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92653       };
92654     }
92655   }
92656
92657   jresult = (void *)result;
92658   return jresult;
92659 }
92660
92661
92662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92663   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92664   int arg2 ;
92665   unsigned int *arg3 = 0 ;
92666   unsigned int temp3 ;
92667
92668   arg1 = (std::vector< unsigned int > *)jarg1;
92669   arg2 = (int)jarg2;
92670   temp3 = (unsigned int)jarg3;
92671   arg3 = &temp3;
92672   {
92673     try {
92674       try {
92675         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92676       }
92677       catch(std::out_of_range &_e) {
92678         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92679         return ;
92680       }
92681
92682     } catch (std::out_of_range& e) {
92683       {
92684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92685       };
92686     } catch (std::exception& e) {
92687       {
92688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92689       };
92690     } catch (Dali::DaliException e) {
92691       {
92692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92693       };
92694     } catch (...) {
92695       {
92696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92697       };
92698     }
92699   }
92700
92701 }
92702
92703
92704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92705   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92706   int arg2 ;
92707   std::vector< unsigned int > *arg3 = 0 ;
92708
92709   arg1 = (std::vector< unsigned int > *)jarg1;
92710   arg2 = (int)jarg2;
92711   arg3 = (std::vector< unsigned int > *)jarg3;
92712   if (!arg3) {
92713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92714     return ;
92715   }
92716   {
92717     try {
92718       try {
92719         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92720       }
92721       catch(std::out_of_range &_e) {
92722         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92723         return ;
92724       }
92725
92726     } catch (std::out_of_range& e) {
92727       {
92728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92729       };
92730     } catch (std::exception& e) {
92731       {
92732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92733       };
92734     } catch (Dali::DaliException e) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92737       };
92738     } catch (...) {
92739       {
92740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92741       };
92742     }
92743   }
92744
92745 }
92746
92747
92748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92749   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92750   int arg2 ;
92751
92752   arg1 = (std::vector< unsigned int > *)jarg1;
92753   arg2 = (int)jarg2;
92754   {
92755     try {
92756       try {
92757         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92758       }
92759       catch(std::out_of_range &_e) {
92760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92761         return ;
92762       }
92763
92764     } catch (std::out_of_range& e) {
92765       {
92766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92767       };
92768     } catch (std::exception& e) {
92769       {
92770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92771       };
92772     } catch (Dali::DaliException e) {
92773       {
92774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92775       };
92776     } catch (...) {
92777       {
92778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92779       };
92780     }
92781   }
92782
92783 }
92784
92785
92786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92787   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92788   int arg2 ;
92789   int arg3 ;
92790
92791   arg1 = (std::vector< unsigned int > *)jarg1;
92792   arg2 = (int)jarg2;
92793   arg3 = (int)jarg3;
92794   {
92795     try {
92796       try {
92797         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92798       }
92799       catch(std::out_of_range &_e) {
92800         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92801         return ;
92802       }
92803       catch(std::invalid_argument &_e) {
92804         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92805         return ;
92806       }
92807
92808     } catch (std::out_of_range& e) {
92809       {
92810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92811       };
92812     } catch (std::exception& e) {
92813       {
92814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92815       };
92816     } catch (Dali::DaliException e) {
92817       {
92818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92819       };
92820     } catch (...) {
92821       {
92822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92823       };
92824     }
92825   }
92826
92827 }
92828
92829
92830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92831   void * jresult ;
92832   unsigned int *arg1 = 0 ;
92833   int arg2 ;
92834   unsigned int temp1 ;
92835   std::vector< unsigned int > *result = 0 ;
92836
92837   temp1 = (unsigned int)jarg1;
92838   arg1 = &temp1;
92839   arg2 = (int)jarg2;
92840   {
92841     try {
92842       try {
92843         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92844       }
92845       catch(std::out_of_range &_e) {
92846         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92847         return 0;
92848       }
92849
92850     } catch (std::out_of_range& e) {
92851       {
92852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92853       };
92854     } catch (std::exception& e) {
92855       {
92856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92857       };
92858     } catch (Dali::DaliException e) {
92859       {
92860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92861       };
92862     } catch (...) {
92863       {
92864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92865       };
92866     }
92867   }
92868
92869   jresult = (void *)result;
92870   return jresult;
92871 }
92872
92873
92874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92875   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92876
92877   arg1 = (std::vector< unsigned int > *)jarg1;
92878   {
92879     try {
92880       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92881     } catch (std::out_of_range& e) {
92882       {
92883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92884       };
92885     } catch (std::exception& e) {
92886       {
92887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92888       };
92889     } catch (Dali::DaliException e) {
92890       {
92891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92892       };
92893     } catch (...) {
92894       {
92895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92896       };
92897     }
92898   }
92899
92900 }
92901
92902
92903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92904   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92905   int arg2 ;
92906   int arg3 ;
92907
92908   arg1 = (std::vector< unsigned int > *)jarg1;
92909   arg2 = (int)jarg2;
92910   arg3 = (int)jarg3;
92911   {
92912     try {
92913       try {
92914         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92915       }
92916       catch(std::out_of_range &_e) {
92917         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92918         return ;
92919       }
92920       catch(std::invalid_argument &_e) {
92921         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92922         return ;
92923       }
92924
92925     } catch (std::out_of_range& e) {
92926       {
92927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92928       };
92929     } catch (std::exception& e) {
92930       {
92931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92932       };
92933     } catch (Dali::DaliException e) {
92934       {
92935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92936       };
92937     } catch (...) {
92938       {
92939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92940       };
92941     }
92942   }
92943
92944 }
92945
92946
92947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92948   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92949   int arg2 ;
92950   std::vector< unsigned int > *arg3 = 0 ;
92951
92952   arg1 = (std::vector< unsigned int > *)jarg1;
92953   arg2 = (int)jarg2;
92954   arg3 = (std::vector< unsigned int > *)jarg3;
92955   if (!arg3) {
92956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92957     return ;
92958   }
92959   {
92960     try {
92961       try {
92962         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92963       }
92964       catch(std::out_of_range &_e) {
92965         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92966         return ;
92967       }
92968
92969     } catch (std::out_of_range& e) {
92970       {
92971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92972       };
92973     } catch (std::exception& e) {
92974       {
92975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92976       };
92977     } catch (Dali::DaliException e) {
92978       {
92979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92980       };
92981     } catch (...) {
92982       {
92983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92984       };
92985     }
92986   }
92987
92988 }
92989
92990
92991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92992   unsigned int jresult ;
92993   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92994   unsigned int *arg2 = 0 ;
92995   unsigned int temp2 ;
92996   bool result;
92997
92998   arg1 = (std::vector< unsigned int > *)jarg1;
92999   temp2 = (unsigned int)jarg2;
93000   arg2 = &temp2;
93001   {
93002     try {
93003       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93004     } catch (std::out_of_range& e) {
93005       {
93006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93007       };
93008     } catch (std::exception& e) {
93009       {
93010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93011       };
93012     } catch (Dali::DaliException e) {
93013       {
93014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93015       };
93016     } catch (...) {
93017       {
93018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93019       };
93020     }
93021   }
93022
93023   jresult = result;
93024   return jresult;
93025 }
93026
93027
93028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93029   int jresult ;
93030   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93031   unsigned int *arg2 = 0 ;
93032   unsigned int temp2 ;
93033   int result;
93034
93035   arg1 = (std::vector< unsigned int > *)jarg1;
93036   temp2 = (unsigned int)jarg2;
93037   arg2 = &temp2;
93038   {
93039     try {
93040       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93041     } catch (std::out_of_range& e) {
93042       {
93043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93044       };
93045     } catch (std::exception& e) {
93046       {
93047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93048       };
93049     } catch (Dali::DaliException e) {
93050       {
93051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93052       };
93053     } catch (...) {
93054       {
93055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93056       };
93057     }
93058   }
93059
93060   jresult = result;
93061   return jresult;
93062 }
93063
93064
93065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93066   int jresult ;
93067   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93068   unsigned int *arg2 = 0 ;
93069   unsigned int temp2 ;
93070   int result;
93071
93072   arg1 = (std::vector< unsigned int > *)jarg1;
93073   temp2 = (unsigned int)jarg2;
93074   arg2 = &temp2;
93075   {
93076     try {
93077       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93078     } catch (std::out_of_range& e) {
93079       {
93080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93081       };
93082     } catch (std::exception& e) {
93083       {
93084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93085       };
93086     } catch (Dali::DaliException e) {
93087       {
93088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93089       };
93090     } catch (...) {
93091       {
93092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93093       };
93094     }
93095   }
93096
93097   jresult = result;
93098   return jresult;
93099 }
93100
93101
93102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93103   unsigned int jresult ;
93104   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93105   unsigned int *arg2 = 0 ;
93106   unsigned int temp2 ;
93107   bool result;
93108
93109   arg1 = (std::vector< unsigned int > *)jarg1;
93110   temp2 = (unsigned int)jarg2;
93111   arg2 = &temp2;
93112   {
93113     try {
93114       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93115     } catch (std::out_of_range& e) {
93116       {
93117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93118       };
93119     } catch (std::exception& e) {
93120       {
93121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93122       };
93123     } catch (Dali::DaliException e) {
93124       {
93125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93126       };
93127     } catch (...) {
93128       {
93129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93130       };
93131     }
93132   }
93133
93134   jresult = result;
93135   return jresult;
93136 }
93137
93138
93139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93140   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93141
93142   arg1 = (std::vector< unsigned int > *)jarg1;
93143   {
93144     try {
93145       delete arg1;
93146     } catch (std::out_of_range& e) {
93147       {
93148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93149       };
93150     } catch (std::exception& e) {
93151       {
93152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93153       };
93154     } catch (Dali::DaliException e) {
93155       {
93156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93157       };
93158     } catch (...) {
93159       {
93160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93161       };
93162     }
93163   }
93164
93165 }
93166
93167
93168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93169   void * jresult ;
93170   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93171
93172   {
93173     try {
93174       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93175     } catch (std::out_of_range& e) {
93176       {
93177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93178       };
93179     } catch (std::exception& e) {
93180       {
93181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93182       };
93183     } catch (Dali::DaliException e) {
93184       {
93185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93186       };
93187     } catch (...) {
93188       {
93189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93190       };
93191     }
93192   }
93193
93194   jresult = (void *)result;
93195   return jresult;
93196 }
93197
93198
93199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93200   void * jresult ;
93201   unsigned int arg1 ;
93202   Dali::Actor arg2 ;
93203   Dali::Actor *argp2 ;
93204   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93205
93206   arg1 = (unsigned int)jarg1;
93207   argp2 = (Dali::Actor *)jarg2;
93208   if (!argp2) {
93209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93210     return 0;
93211   }
93212   arg2 = *argp2;
93213   {
93214     try {
93215       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93216     } catch (std::out_of_range& e) {
93217       {
93218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93219       };
93220     } catch (std::exception& e) {
93221       {
93222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93223       };
93224     } catch (Dali::DaliException e) {
93225       {
93226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93227       };
93228     } catch (...) {
93229       {
93230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93231       };
93232     }
93233   }
93234
93235   jresult = (void *)result;
93236   return jresult;
93237 }
93238
93239
93240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93241   void * jresult ;
93242   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93243   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93244
93245   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93246   if (!arg1) {
93247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93248     return 0;
93249   }
93250   {
93251     try {
93252       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93253     } catch (std::out_of_range& e) {
93254       {
93255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93256       };
93257     } catch (std::exception& e) {
93258       {
93259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93260       };
93261     } catch (Dali::DaliException e) {
93262       {
93263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93264       };
93265     } catch (...) {
93266       {
93267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93268       };
93269     }
93270   }
93271
93272   jresult = (void *)result;
93273   return jresult;
93274 }
93275
93276
93277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93278   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93279   unsigned int arg2 ;
93280
93281   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93282   arg2 = (unsigned int)jarg2;
93283   if (arg1) (arg1)->first = arg2;
93284 }
93285
93286
93287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93288   unsigned int jresult ;
93289   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93290   unsigned int result;
93291
93292   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93293   result = (unsigned int) ((arg1)->first);
93294   jresult = result;
93295   return jresult;
93296 }
93297
93298
93299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93300   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93301   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93302
93303   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93304   arg2 = (Dali::Actor *)jarg2;
93305   if (arg1) (arg1)->second = *arg2;
93306 }
93307
93308
93309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93310   void * jresult ;
93311   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93312   Dali::Actor *result = 0 ;
93313
93314   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93315   result = (Dali::Actor *)& ((arg1)->second);
93316   jresult = (void *)result;
93317   return jresult;
93318 }
93319
93320
93321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93322   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93323
93324   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93325   {
93326     try {
93327       delete arg1;
93328     } catch (std::out_of_range& e) {
93329       {
93330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93331       };
93332     } catch (std::exception& e) {
93333       {
93334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93335       };
93336     } catch (Dali::DaliException e) {
93337       {
93338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93339       };
93340     } catch (...) {
93341       {
93342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93343       };
93344     }
93345   }
93346
93347 }
93348
93349
93350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93351   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93352
93353   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93354   {
93355     try {
93356       (arg1)->clear();
93357     } catch (std::out_of_range& e) {
93358       {
93359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93360       };
93361     } catch (std::exception& e) {
93362       {
93363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93364       };
93365     } catch (Dali::DaliException e) {
93366       {
93367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93368       };
93369     } catch (...) {
93370       {
93371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93372       };
93373     }
93374   }
93375
93376 }
93377
93378
93379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93380   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93381   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93382
93383   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93384   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93385   if (!arg2) {
93386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93387     return ;
93388   }
93389   {
93390     try {
93391       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93392     } catch (std::out_of_range& e) {
93393       {
93394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93395       };
93396     } catch (std::exception& e) {
93397       {
93398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93399       };
93400     } catch (Dali::DaliException e) {
93401       {
93402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93403       };
93404     } catch (...) {
93405       {
93406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93407       };
93408     }
93409   }
93410
93411 }
93412
93413
93414 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93415   unsigned long jresult ;
93416   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93417   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93418
93419   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93420   {
93421     try {
93422       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93423     } catch (std::out_of_range& e) {
93424       {
93425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93426       };
93427     } catch (std::exception& e) {
93428       {
93429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93430       };
93431     } catch (Dali::DaliException e) {
93432       {
93433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93434       };
93435     } catch (...) {
93436       {
93437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93438       };
93439     }
93440   }
93441
93442   jresult = (unsigned long)result;
93443   return jresult;
93444 }
93445
93446
93447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93448   unsigned long jresult ;
93449   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93450   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93451
93452   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93453   {
93454     try {
93455       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93456     } catch (std::out_of_range& e) {
93457       {
93458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93459       };
93460     } catch (std::exception& e) {
93461       {
93462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93463       };
93464     } catch (Dali::DaliException e) {
93465       {
93466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93467       };
93468     } catch (...) {
93469       {
93470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93471       };
93472     }
93473   }
93474
93475   jresult = (unsigned long)result;
93476   return jresult;
93477 }
93478
93479
93480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93481   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93482   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93483
93484   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93485   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93486   {
93487     try {
93488       (arg1)->reserve(arg2);
93489     } catch (std::out_of_range& e) {
93490       {
93491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93492       };
93493     } catch (std::exception& e) {
93494       {
93495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93496       };
93497     } catch (Dali::DaliException e) {
93498       {
93499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93500       };
93501     } catch (...) {
93502       {
93503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93504       };
93505     }
93506   }
93507
93508 }
93509
93510
93511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93512   void * jresult ;
93513   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93514
93515   {
93516     try {
93517       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93518     } catch (std::out_of_range& e) {
93519       {
93520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93521       };
93522     } catch (std::exception& e) {
93523       {
93524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93525       };
93526     } catch (Dali::DaliException e) {
93527       {
93528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93529       };
93530     } catch (...) {
93531       {
93532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93533       };
93534     }
93535   }
93536
93537   jresult = (void *)result;
93538   return jresult;
93539 }
93540
93541
93542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93543   void * jresult ;
93544   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93545   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93546
93547   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93548   if (!arg1) {
93549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93550     return 0;
93551   }
93552   {
93553     try {
93554       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);
93555     } catch (std::out_of_range& e) {
93556       {
93557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93558       };
93559     } catch (std::exception& e) {
93560       {
93561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93562       };
93563     } catch (Dali::DaliException e) {
93564       {
93565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93566       };
93567     } catch (...) {
93568       {
93569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93570       };
93571     }
93572   }
93573
93574   jresult = (void *)result;
93575   return jresult;
93576 }
93577
93578
93579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93580   void * jresult ;
93581   int arg1 ;
93582   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93583
93584   arg1 = (int)jarg1;
93585   {
93586     try {
93587       try {
93588         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);
93589       }
93590       catch(std::out_of_range &_e) {
93591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93592         return 0;
93593       }
93594
93595     } catch (std::out_of_range& e) {
93596       {
93597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93598       };
93599     } catch (std::exception& e) {
93600       {
93601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93602       };
93603     } catch (Dali::DaliException e) {
93604       {
93605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93606       };
93607     } catch (...) {
93608       {
93609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93610       };
93611     }
93612   }
93613
93614   jresult = (void *)result;
93615   return jresult;
93616 }
93617
93618
93619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93620   void * jresult ;
93621   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93622   int arg2 ;
93623   std::pair< unsigned int,Dali::Actor > result;
93624
93625   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93626   arg2 = (int)jarg2;
93627   {
93628     try {
93629       try {
93630         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93631       }
93632       catch(std::out_of_range &_e) {
93633         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93634         return 0;
93635       }
93636
93637     } catch (std::out_of_range& e) {
93638       {
93639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93640       };
93641     } catch (std::exception& e) {
93642       {
93643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93644       };
93645     } catch (Dali::DaliException e) {
93646       {
93647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93648       };
93649     } catch (...) {
93650       {
93651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93652       };
93653     }
93654   }
93655
93656   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93657   return jresult;
93658 }
93659
93660
93661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93662   void * jresult ;
93663   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93664   int arg2 ;
93665   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93666
93667   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93668   arg2 = (int)jarg2;
93669   {
93670     try {
93671       try {
93672         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93673       }
93674       catch(std::out_of_range &_e) {
93675         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93676         return 0;
93677       }
93678
93679     } catch (std::out_of_range& e) {
93680       {
93681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93682       };
93683     } catch (std::exception& e) {
93684       {
93685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93686       };
93687     } catch (Dali::DaliException e) {
93688       {
93689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93690       };
93691     } catch (...) {
93692       {
93693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93694       };
93695     }
93696   }
93697
93698   jresult = (void *)result;
93699   return jresult;
93700 }
93701
93702
93703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93704   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93705   int arg2 ;
93706   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93707
93708   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93709   arg2 = (int)jarg2;
93710   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93711   if (!arg3) {
93712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93713     return ;
93714   }
93715   {
93716     try {
93717       try {
93718         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);
93719       }
93720       catch(std::out_of_range &_e) {
93721         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93722         return ;
93723       }
93724
93725     } catch (std::out_of_range& e) {
93726       {
93727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93728       };
93729     } catch (std::exception& e) {
93730       {
93731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93732       };
93733     } catch (Dali::DaliException e) {
93734       {
93735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93736       };
93737     } catch (...) {
93738       {
93739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93740       };
93741     }
93742   }
93743
93744 }
93745
93746
93747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93748   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93749   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93750
93751   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93752   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93753   if (!arg2) {
93754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93755     return ;
93756   }
93757   {
93758     try {
93759       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);
93760     } catch (std::out_of_range& e) {
93761       {
93762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93763       };
93764     } catch (std::exception& e) {
93765       {
93766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93767       };
93768     } catch (Dali::DaliException e) {
93769       {
93770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93771       };
93772     } catch (...) {
93773       {
93774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93775       };
93776     }
93777   }
93778
93779 }
93780
93781
93782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93783   void * jresult ;
93784   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93785   int arg2 ;
93786   int arg3 ;
93787   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93788
93789   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93790   arg2 = (int)jarg2;
93791   arg3 = (int)jarg3;
93792   {
93793     try {
93794       try {
93795         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);
93796       }
93797       catch(std::out_of_range &_e) {
93798         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93799         return 0;
93800       }
93801       catch(std::invalid_argument &_e) {
93802         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93803         return 0;
93804       }
93805
93806     } catch (std::out_of_range& e) {
93807       {
93808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93809       };
93810     } catch (std::exception& e) {
93811       {
93812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93813       };
93814     } catch (Dali::DaliException e) {
93815       {
93816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93817       };
93818     } catch (...) {
93819       {
93820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93821       };
93822     }
93823   }
93824
93825   jresult = (void *)result;
93826   return jresult;
93827 }
93828
93829
93830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93831   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93832   int arg2 ;
93833   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93834
93835   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93836   arg2 = (int)jarg2;
93837   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93838   if (!arg3) {
93839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93840     return ;
93841   }
93842   {
93843     try {
93844       try {
93845         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);
93846       }
93847       catch(std::out_of_range &_e) {
93848         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93849         return ;
93850       }
93851
93852     } catch (std::out_of_range& e) {
93853       {
93854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93855       };
93856     } catch (std::exception& e) {
93857       {
93858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93859       };
93860     } catch (Dali::DaliException e) {
93861       {
93862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93863       };
93864     } catch (...) {
93865       {
93866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93867       };
93868     }
93869   }
93870
93871 }
93872
93873
93874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93875   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93876   int arg2 ;
93877   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93878
93879   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93880   arg2 = (int)jarg2;
93881   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93882   if (!arg3) {
93883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93884     return ;
93885   }
93886   {
93887     try {
93888       try {
93889         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);
93890       }
93891       catch(std::out_of_range &_e) {
93892         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93893         return ;
93894       }
93895
93896     } catch (std::out_of_range& e) {
93897       {
93898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93899       };
93900     } catch (std::exception& e) {
93901       {
93902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93903       };
93904     } catch (Dali::DaliException e) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93907       };
93908     } catch (...) {
93909       {
93910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93911       };
93912     }
93913   }
93914
93915 }
93916
93917
93918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93919   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93920   int arg2 ;
93921
93922   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93923   arg2 = (int)jarg2;
93924   {
93925     try {
93926       try {
93927         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93928       }
93929       catch(std::out_of_range &_e) {
93930         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93931         return ;
93932       }
93933
93934     } catch (std::out_of_range& e) {
93935       {
93936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93937       };
93938     } catch (std::exception& e) {
93939       {
93940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93941       };
93942     } catch (Dali::DaliException e) {
93943       {
93944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93945       };
93946     } catch (...) {
93947       {
93948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93949       };
93950     }
93951   }
93952
93953 }
93954
93955
93956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93957   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93958   int arg2 ;
93959   int arg3 ;
93960
93961   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93962   arg2 = (int)jarg2;
93963   arg3 = (int)jarg3;
93964   {
93965     try {
93966       try {
93967         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93968       }
93969       catch(std::out_of_range &_e) {
93970         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93971         return ;
93972       }
93973       catch(std::invalid_argument &_e) {
93974         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93975         return ;
93976       }
93977
93978     } catch (std::out_of_range& e) {
93979       {
93980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93981       };
93982     } catch (std::exception& e) {
93983       {
93984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93985       };
93986     } catch (Dali::DaliException e) {
93987       {
93988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93989       };
93990     } catch (...) {
93991       {
93992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93993       };
93994     }
93995   }
93996
93997 }
93998
93999
94000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94001   void * jresult ;
94002   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94003   int arg2 ;
94004   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94005
94006   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94007   if (!arg1) {
94008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94009     return 0;
94010   }
94011   arg2 = (int)jarg2;
94012   {
94013     try {
94014       try {
94015         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);
94016       }
94017       catch(std::out_of_range &_e) {
94018         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94019         return 0;
94020       }
94021
94022     } catch (std::out_of_range& e) {
94023       {
94024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94025       };
94026     } catch (std::exception& e) {
94027       {
94028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94029       };
94030     } catch (Dali::DaliException e) {
94031       {
94032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94033       };
94034     } catch (...) {
94035       {
94036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94037       };
94038     }
94039   }
94040
94041   jresult = (void *)result;
94042   return jresult;
94043 }
94044
94045
94046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94047   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94048
94049   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94050   {
94051     try {
94052       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94053     } catch (std::out_of_range& e) {
94054       {
94055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94056       };
94057     } catch (std::exception& e) {
94058       {
94059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94060       };
94061     } catch (Dali::DaliException e) {
94062       {
94063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94064       };
94065     } catch (...) {
94066       {
94067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94068       };
94069     }
94070   }
94071
94072 }
94073
94074
94075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94076   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94077   int arg2 ;
94078   int arg3 ;
94079
94080   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94081   arg2 = (int)jarg2;
94082   arg3 = (int)jarg3;
94083   {
94084     try {
94085       try {
94086         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94087       }
94088       catch(std::out_of_range &_e) {
94089         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94090         return ;
94091       }
94092       catch(std::invalid_argument &_e) {
94093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94094         return ;
94095       }
94096
94097     } catch (std::out_of_range& e) {
94098       {
94099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94100       };
94101     } catch (std::exception& e) {
94102       {
94103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94104       };
94105     } catch (Dali::DaliException e) {
94106       {
94107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94108       };
94109     } catch (...) {
94110       {
94111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94112       };
94113     }
94114   }
94115
94116 }
94117
94118
94119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94120   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94121   int arg2 ;
94122   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94123
94124   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94125   arg2 = (int)jarg2;
94126   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94127   if (!arg3) {
94128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94129     return ;
94130   }
94131   {
94132     try {
94133       try {
94134         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);
94135       }
94136       catch(std::out_of_range &_e) {
94137         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94138         return ;
94139       }
94140
94141     } catch (std::out_of_range& e) {
94142       {
94143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94144       };
94145     } catch (std::exception& e) {
94146       {
94147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94148       };
94149     } catch (Dali::DaliException e) {
94150       {
94151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94152       };
94153     } catch (...) {
94154       {
94155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94156       };
94157     }
94158   }
94159
94160 }
94161
94162
94163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94164   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94165
94166   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94167   {
94168     try {
94169       delete arg1;
94170     } catch (std::out_of_range& e) {
94171       {
94172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94173       };
94174     } catch (std::exception& e) {
94175       {
94176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94177       };
94178     } catch (Dali::DaliException e) {
94179       {
94180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94181       };
94182     } catch (...) {
94183       {
94184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94185       };
94186     }
94187   }
94188
94189 }
94190
94191
94192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94193   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94194
94195   arg1 = (std::vector< Dali::Actor > *)jarg1;
94196   {
94197     try {
94198       (arg1)->clear();
94199     } catch (std::out_of_range& e) {
94200       {
94201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94202       };
94203     } catch (std::exception& e) {
94204       {
94205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94206       };
94207     } catch (Dali::DaliException e) {
94208       {
94209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94210       };
94211     } catch (...) {
94212       {
94213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94214       };
94215     }
94216   }
94217
94218 }
94219
94220
94221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94222   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94223   Dali::Actor *arg2 = 0 ;
94224
94225   arg1 = (std::vector< Dali::Actor > *)jarg1;
94226   arg2 = (Dali::Actor *)jarg2;
94227   if (!arg2) {
94228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94229     return ;
94230   }
94231   {
94232     try {
94233       (arg1)->push_back((Dali::Actor const &)*arg2);
94234     } catch (std::out_of_range& e) {
94235       {
94236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94237       };
94238     } catch (std::exception& e) {
94239       {
94240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94241       };
94242     } catch (Dali::DaliException e) {
94243       {
94244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94245       };
94246     } catch (...) {
94247       {
94248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94249       };
94250     }
94251   }
94252
94253 }
94254
94255
94256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94257   unsigned long jresult ;
94258   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94259   std::vector< Dali::Actor >::size_type result;
94260
94261   arg1 = (std::vector< Dali::Actor > *)jarg1;
94262   {
94263     try {
94264       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94265     } catch (std::out_of_range& e) {
94266       {
94267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94268       };
94269     } catch (std::exception& e) {
94270       {
94271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94272       };
94273     } catch (Dali::DaliException e) {
94274       {
94275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94276       };
94277     } catch (...) {
94278       {
94279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94280       };
94281     }
94282   }
94283
94284   jresult = (unsigned long)result;
94285   return jresult;
94286 }
94287
94288
94289 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94290   unsigned long jresult ;
94291   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94292   std::vector< Dali::Actor >::size_type result;
94293
94294   arg1 = (std::vector< Dali::Actor > *)jarg1;
94295   {
94296     try {
94297       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94298     } catch (std::out_of_range& e) {
94299       {
94300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94301       };
94302     } catch (std::exception& e) {
94303       {
94304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94305       };
94306     } catch (Dali::DaliException e) {
94307       {
94308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94309       };
94310     } catch (...) {
94311       {
94312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94313       };
94314     }
94315   }
94316
94317   jresult = (unsigned long)result;
94318   return jresult;
94319 }
94320
94321
94322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94323   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94324   std::vector< Dali::Actor >::size_type arg2 ;
94325
94326   arg1 = (std::vector< Dali::Actor > *)jarg1;
94327   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94328   {
94329     try {
94330       (arg1)->reserve(arg2);
94331     } catch (std::out_of_range& e) {
94332       {
94333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94334       };
94335     } catch (std::exception& e) {
94336       {
94337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94338       };
94339     } catch (Dali::DaliException e) {
94340       {
94341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94342       };
94343     } catch (...) {
94344       {
94345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94346       };
94347     }
94348   }
94349
94350 }
94351
94352
94353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94354   void * jresult ;
94355   std::vector< Dali::Actor > *result = 0 ;
94356
94357   {
94358     try {
94359       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94360     } catch (std::out_of_range& e) {
94361       {
94362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94363       };
94364     } catch (std::exception& e) {
94365       {
94366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94367       };
94368     } catch (Dali::DaliException e) {
94369       {
94370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94371       };
94372     } catch (...) {
94373       {
94374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94375       };
94376     }
94377   }
94378
94379   jresult = (void *)result;
94380   return jresult;
94381 }
94382
94383
94384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94385   void * jresult ;
94386   std::vector< Dali::Actor > *arg1 = 0 ;
94387   std::vector< Dali::Actor > *result = 0 ;
94388
94389   arg1 = (std::vector< Dali::Actor > *)jarg1;
94390   if (!arg1) {
94391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94392     return 0;
94393   }
94394   {
94395     try {
94396       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94397     } catch (std::out_of_range& e) {
94398       {
94399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94400       };
94401     } catch (std::exception& e) {
94402       {
94403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94404       };
94405     } catch (Dali::DaliException e) {
94406       {
94407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94408       };
94409     } catch (...) {
94410       {
94411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94412       };
94413     }
94414   }
94415
94416   jresult = (void *)result;
94417   return jresult;
94418 }
94419
94420
94421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94422   void * jresult ;
94423   int arg1 ;
94424   std::vector< Dali::Actor > *result = 0 ;
94425
94426   arg1 = (int)jarg1;
94427   {
94428     try {
94429       try {
94430         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94431       }
94432       catch(std::out_of_range &_e) {
94433         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94434         return 0;
94435       }
94436
94437     } catch (std::out_of_range& e) {
94438       {
94439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94440       };
94441     } catch (std::exception& e) {
94442       {
94443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94444       };
94445     } catch (Dali::DaliException e) {
94446       {
94447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94448       };
94449     } catch (...) {
94450       {
94451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94452       };
94453     }
94454   }
94455
94456   jresult = (void *)result;
94457   return jresult;
94458 }
94459
94460
94461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94462   void * jresult ;
94463   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94464   int arg2 ;
94465   Dali::Actor result;
94466
94467   arg1 = (std::vector< Dali::Actor > *)jarg1;
94468   arg2 = (int)jarg2;
94469   {
94470     try {
94471       try {
94472         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94473       }
94474       catch(std::out_of_range &_e) {
94475         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94476         return 0;
94477       }
94478
94479     } catch (std::out_of_range& e) {
94480       {
94481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94482       };
94483     } catch (std::exception& e) {
94484       {
94485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94486       };
94487     } catch (Dali::DaliException e) {
94488       {
94489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94490       };
94491     } catch (...) {
94492       {
94493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94494       };
94495     }
94496   }
94497
94498   jresult = new Dali::Actor((const Dali::Actor &)result);
94499   return jresult;
94500 }
94501
94502
94503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94504   void * jresult ;
94505   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94506   int arg2 ;
94507   Dali::Actor *result = 0 ;
94508
94509   arg1 = (std::vector< Dali::Actor > *)jarg1;
94510   arg2 = (int)jarg2;
94511   {
94512     try {
94513       try {
94514         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94515       }
94516       catch(std::out_of_range &_e) {
94517         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94518         return 0;
94519       }
94520
94521     } catch (std::out_of_range& e) {
94522       {
94523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94524       };
94525     } catch (std::exception& e) {
94526       {
94527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94528       };
94529     } catch (Dali::DaliException e) {
94530       {
94531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94532       };
94533     } catch (...) {
94534       {
94535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94536       };
94537     }
94538   }
94539
94540   jresult = (void *)result;
94541   return jresult;
94542 }
94543
94544
94545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94546   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94547   int arg2 ;
94548   Dali::Actor *arg3 = 0 ;
94549
94550   arg1 = (std::vector< Dali::Actor > *)jarg1;
94551   arg2 = (int)jarg2;
94552   arg3 = (Dali::Actor *)jarg3;
94553   if (!arg3) {
94554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94555     return ;
94556   }
94557   {
94558     try {
94559       try {
94560         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94561       }
94562       catch(std::out_of_range &_e) {
94563         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94564         return ;
94565       }
94566
94567     } catch (std::out_of_range& e) {
94568       {
94569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94570       };
94571     } catch (std::exception& e) {
94572       {
94573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94574       };
94575     } catch (Dali::DaliException e) {
94576       {
94577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94578       };
94579     } catch (...) {
94580       {
94581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94582       };
94583     }
94584   }
94585
94586 }
94587
94588
94589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94590   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94591   std::vector< Dali::Actor > *arg2 = 0 ;
94592
94593   arg1 = (std::vector< Dali::Actor > *)jarg1;
94594   arg2 = (std::vector< Dali::Actor > *)jarg2;
94595   if (!arg2) {
94596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94597     return ;
94598   }
94599   {
94600     try {
94601       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94602     } catch (std::out_of_range& e) {
94603       {
94604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94605       };
94606     } catch (std::exception& e) {
94607       {
94608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94609       };
94610     } catch (Dali::DaliException e) {
94611       {
94612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94613       };
94614     } catch (...) {
94615       {
94616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94617       };
94618     }
94619   }
94620
94621 }
94622
94623
94624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94625   void * jresult ;
94626   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94627   int arg2 ;
94628   int arg3 ;
94629   std::vector< Dali::Actor > *result = 0 ;
94630
94631   arg1 = (std::vector< Dali::Actor > *)jarg1;
94632   arg2 = (int)jarg2;
94633   arg3 = (int)jarg3;
94634   {
94635     try {
94636       try {
94637         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94638       }
94639       catch(std::out_of_range &_e) {
94640         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94641         return 0;
94642       }
94643       catch(std::invalid_argument &_e) {
94644         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94645         return 0;
94646       }
94647
94648     } catch (std::out_of_range& e) {
94649       {
94650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94651       };
94652     } catch (std::exception& e) {
94653       {
94654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94655       };
94656     } catch (Dali::DaliException e) {
94657       {
94658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94659       };
94660     } catch (...) {
94661       {
94662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94663       };
94664     }
94665   }
94666
94667   jresult = (void *)result;
94668   return jresult;
94669 }
94670
94671
94672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94673   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94674   int arg2 ;
94675   Dali::Actor *arg3 = 0 ;
94676
94677   arg1 = (std::vector< Dali::Actor > *)jarg1;
94678   arg2 = (int)jarg2;
94679   arg3 = (Dali::Actor *)jarg3;
94680   if (!arg3) {
94681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94682     return ;
94683   }
94684   {
94685     try {
94686       try {
94687         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94688       }
94689       catch(std::out_of_range &_e) {
94690         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94691         return ;
94692       }
94693
94694     } catch (std::out_of_range& e) {
94695       {
94696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94697       };
94698     } catch (std::exception& e) {
94699       {
94700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94701       };
94702     } catch (Dali::DaliException e) {
94703       {
94704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94705       };
94706     } catch (...) {
94707       {
94708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94709       };
94710     }
94711   }
94712
94713 }
94714
94715
94716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94717   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94718   int arg2 ;
94719   std::vector< Dali::Actor > *arg3 = 0 ;
94720
94721   arg1 = (std::vector< Dali::Actor > *)jarg1;
94722   arg2 = (int)jarg2;
94723   arg3 = (std::vector< Dali::Actor > *)jarg3;
94724   if (!arg3) {
94725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94726     return ;
94727   }
94728   {
94729     try {
94730       try {
94731         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94732       }
94733       catch(std::out_of_range &_e) {
94734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94735         return ;
94736       }
94737
94738     } catch (std::out_of_range& e) {
94739       {
94740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94741       };
94742     } catch (std::exception& e) {
94743       {
94744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94745       };
94746     } catch (Dali::DaliException e) {
94747       {
94748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94749       };
94750     } catch (...) {
94751       {
94752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94753       };
94754     }
94755   }
94756
94757 }
94758
94759
94760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94761   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94762   int arg2 ;
94763
94764   arg1 = (std::vector< Dali::Actor > *)jarg1;
94765   arg2 = (int)jarg2;
94766   {
94767     try {
94768       try {
94769         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94770       }
94771       catch(std::out_of_range &_e) {
94772         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94773         return ;
94774       }
94775
94776     } catch (std::out_of_range& e) {
94777       {
94778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94779       };
94780     } catch (std::exception& e) {
94781       {
94782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94783       };
94784     } catch (Dali::DaliException e) {
94785       {
94786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94787       };
94788     } catch (...) {
94789       {
94790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94791       };
94792     }
94793   }
94794
94795 }
94796
94797
94798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94799   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94800   int arg2 ;
94801   int arg3 ;
94802
94803   arg1 = (std::vector< Dali::Actor > *)jarg1;
94804   arg2 = (int)jarg2;
94805   arg3 = (int)jarg3;
94806   {
94807     try {
94808       try {
94809         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94810       }
94811       catch(std::out_of_range &_e) {
94812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94813         return ;
94814       }
94815       catch(std::invalid_argument &_e) {
94816         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94817         return ;
94818       }
94819
94820     } catch (std::out_of_range& e) {
94821       {
94822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94823       };
94824     } catch (std::exception& e) {
94825       {
94826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94827       };
94828     } catch (Dali::DaliException e) {
94829       {
94830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94831       };
94832     } catch (...) {
94833       {
94834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94835       };
94836     }
94837   }
94838
94839 }
94840
94841
94842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94843   void * jresult ;
94844   Dali::Actor *arg1 = 0 ;
94845   int arg2 ;
94846   std::vector< Dali::Actor > *result = 0 ;
94847
94848   arg1 = (Dali::Actor *)jarg1;
94849   if (!arg1) {
94850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94851     return 0;
94852   }
94853   arg2 = (int)jarg2;
94854   {
94855     try {
94856       try {
94857         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94858       }
94859       catch(std::out_of_range &_e) {
94860         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94861         return 0;
94862       }
94863
94864     } catch (std::out_of_range& e) {
94865       {
94866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94867       };
94868     } catch (std::exception& e) {
94869       {
94870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94871       };
94872     } catch (Dali::DaliException e) {
94873       {
94874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94875       };
94876     } catch (...) {
94877       {
94878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94879       };
94880     }
94881   }
94882
94883   jresult = (void *)result;
94884   return jresult;
94885 }
94886
94887
94888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94889   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94890
94891   arg1 = (std::vector< Dali::Actor > *)jarg1;
94892   {
94893     try {
94894       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94895     } catch (std::out_of_range& e) {
94896       {
94897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94898       };
94899     } catch (std::exception& e) {
94900       {
94901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94902       };
94903     } catch (Dali::DaliException e) {
94904       {
94905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94906       };
94907     } catch (...) {
94908       {
94909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94910       };
94911     }
94912   }
94913
94914 }
94915
94916
94917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94918   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94919   int arg2 ;
94920   int arg3 ;
94921
94922   arg1 = (std::vector< Dali::Actor > *)jarg1;
94923   arg2 = (int)jarg2;
94924   arg3 = (int)jarg3;
94925   {
94926     try {
94927       try {
94928         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94929       }
94930       catch(std::out_of_range &_e) {
94931         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94932         return ;
94933       }
94934       catch(std::invalid_argument &_e) {
94935         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94936         return ;
94937       }
94938
94939     } catch (std::out_of_range& e) {
94940       {
94941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94942       };
94943     } catch (std::exception& e) {
94944       {
94945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94946       };
94947     } catch (Dali::DaliException e) {
94948       {
94949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94950       };
94951     } catch (...) {
94952       {
94953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94954       };
94955     }
94956   }
94957
94958 }
94959
94960
94961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94962   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94963   int arg2 ;
94964   std::vector< Dali::Actor > *arg3 = 0 ;
94965
94966   arg1 = (std::vector< Dali::Actor > *)jarg1;
94967   arg2 = (int)jarg2;
94968   arg3 = (std::vector< Dali::Actor > *)jarg3;
94969   if (!arg3) {
94970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94971     return ;
94972   }
94973   {
94974     try {
94975       try {
94976         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94977       }
94978       catch(std::out_of_range &_e) {
94979         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94980         return ;
94981       }
94982
94983     } catch (std::out_of_range& e) {
94984       {
94985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94986       };
94987     } catch (std::exception& e) {
94988       {
94989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94990       };
94991     } catch (Dali::DaliException e) {
94992       {
94993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94994       };
94995     } catch (...) {
94996       {
94997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94998       };
94999     }
95000   }
95001
95002 }
95003
95004
95005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95006   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95007
95008   arg1 = (std::vector< Dali::Actor > *)jarg1;
95009   {
95010     try {
95011       delete arg1;
95012     } catch (std::out_of_range& e) {
95013       {
95014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95015       };
95016     } catch (std::exception& e) {
95017       {
95018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95019       };
95020     } catch (Dali::DaliException e) {
95021       {
95022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95023       };
95024     } catch (...) {
95025       {
95026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95027       };
95028     }
95029   }
95030
95031 }
95032
95033
95034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95035   unsigned int jresult ;
95036   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95037   bool result;
95038
95039   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95040   {
95041     try {
95042       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95043     } catch (std::out_of_range& e) {
95044       {
95045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95046       };
95047     } catch (std::exception& e) {
95048       {
95049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95050       };
95051     } catch (Dali::DaliException e) {
95052       {
95053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95054       };
95055     } catch (...) {
95056       {
95057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95058       };
95059     }
95060   }
95061
95062   jresult = result;
95063   return jresult;
95064 }
95065
95066
95067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95068   unsigned long jresult ;
95069   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95070   std::size_t result;
95071
95072   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95073   {
95074     try {
95075       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95076     } catch (std::out_of_range& e) {
95077       {
95078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95079       };
95080     } catch (std::exception& e) {
95081       {
95082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95083       };
95084     } catch (Dali::DaliException e) {
95085       {
95086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95087       };
95088     } catch (...) {
95089       {
95090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95091       };
95092     }
95093   }
95094
95095   jresult = (unsigned long)result;
95096   return jresult;
95097 }
95098
95099
95100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95101   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95102   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95103
95104   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95105   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95106   {
95107     try {
95108       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95109     } catch (std::out_of_range& e) {
95110       {
95111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95112       };
95113     } catch (std::exception& e) {
95114       {
95115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95116       };
95117     } catch (Dali::DaliException e) {
95118       {
95119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95120       };
95121     } catch (...) {
95122       {
95123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95124       };
95125     }
95126   }
95127
95128 }
95129
95130
95131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95132   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95133   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95134
95135   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95136   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95137   {
95138     try {
95139       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95140     } catch (std::out_of_range& e) {
95141       {
95142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95143       };
95144     } catch (std::exception& e) {
95145       {
95146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95147       };
95148     } catch (Dali::DaliException e) {
95149       {
95150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95151       };
95152     } catch (...) {
95153       {
95154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95155       };
95156     }
95157   }
95158
95159 }
95160
95161
95162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95163   unsigned int jresult ;
95164   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95165   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95166   bool result;
95167
95168   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95169   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95170   if (!arg2) {
95171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95172     return 0;
95173   }
95174   {
95175     try {
95176       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95177     } catch (std::out_of_range& e) {
95178       {
95179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95180       };
95181     } catch (std::exception& e) {
95182       {
95183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95184       };
95185     } catch (Dali::DaliException e) {
95186       {
95187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95188       };
95189     } catch (...) {
95190       {
95191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95192       };
95193     }
95194   }
95195
95196   jresult = result;
95197   return jresult;
95198 }
95199
95200
95201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95202   void * jresult ;
95203   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95204
95205   {
95206     try {
95207       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95208     } catch (std::out_of_range& e) {
95209       {
95210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95211       };
95212     } catch (std::exception& e) {
95213       {
95214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95215       };
95216     } catch (Dali::DaliException e) {
95217       {
95218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95219       };
95220     } catch (...) {
95221       {
95222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95223       };
95224     }
95225   }
95226
95227   jresult = (void *)result;
95228   return jresult;
95229 }
95230
95231
95232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95233   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95234
95235   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95236   {
95237     try {
95238       delete arg1;
95239     } catch (std::out_of_range& e) {
95240       {
95241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95242       };
95243     } catch (std::exception& e) {
95244       {
95245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95246       };
95247     } catch (Dali::DaliException e) {
95248       {
95249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95250       };
95251     } catch (...) {
95252       {
95253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95254       };
95255     }
95256   }
95257
95258 }
95259
95260
95261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95262   unsigned int jresult ;
95263   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95264   bool result;
95265
95266   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95267   {
95268     try {
95269       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);
95270     } catch (std::out_of_range& e) {
95271       {
95272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95273       };
95274     } catch (std::exception& e) {
95275       {
95276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95277       };
95278     } catch (Dali::DaliException e) {
95279       {
95280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95281       };
95282     } catch (...) {
95283       {
95284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95285       };
95286     }
95287   }
95288
95289   jresult = result;
95290   return jresult;
95291 }
95292
95293
95294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95295   unsigned long jresult ;
95296   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95297   std::size_t result;
95298
95299   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95300   {
95301     try {
95302       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);
95303     } catch (std::out_of_range& e) {
95304       {
95305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95306       };
95307     } catch (std::exception& e) {
95308       {
95309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95310       };
95311     } catch (Dali::DaliException e) {
95312       {
95313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95314       };
95315     } catch (...) {
95316       {
95317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95318       };
95319     }
95320   }
95321
95322   jresult = (unsigned long)result;
95323   return jresult;
95324 }
95325
95326
95327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95328   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95329   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95330
95331   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95332   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95333   {
95334     try {
95335       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95336     } catch (std::out_of_range& e) {
95337       {
95338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95339       };
95340     } catch (std::exception& e) {
95341       {
95342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95343       };
95344     } catch (Dali::DaliException e) {
95345       {
95346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95347       };
95348     } catch (...) {
95349       {
95350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95351       };
95352     }
95353   }
95354
95355 }
95356
95357
95358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95359   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95360   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95361
95362   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95363   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95364   {
95365     try {
95366       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95367     } catch (std::out_of_range& e) {
95368       {
95369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95370       };
95371     } catch (std::exception& e) {
95372       {
95373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95374       };
95375     } catch (Dali::DaliException e) {
95376       {
95377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95378       };
95379     } catch (...) {
95380       {
95381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95382       };
95383     }
95384   }
95385
95386 }
95387
95388
95389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95390   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95391   Dali::Actor arg2 ;
95392   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95393   Dali::Actor *argp2 ;
95394
95395   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95396   argp2 = (Dali::Actor *)jarg2;
95397   if (!argp2) {
95398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95399     return ;
95400   }
95401   arg2 = *argp2;
95402   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95403   {
95404     try {
95405       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95406     } catch (std::out_of_range& e) {
95407       {
95408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95409       };
95410     } catch (std::exception& e) {
95411       {
95412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95413       };
95414     } catch (Dali::DaliException e) {
95415       {
95416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95417       };
95418     } catch (...) {
95419       {
95420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95421       };
95422     }
95423   }
95424
95425 }
95426
95427
95428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95429   void * jresult ;
95430   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95431
95432   {
95433     try {
95434       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95435     } catch (std::out_of_range& e) {
95436       {
95437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95438       };
95439     } catch (std::exception& e) {
95440       {
95441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95442       };
95443     } catch (Dali::DaliException e) {
95444       {
95445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95446       };
95447     } catch (...) {
95448       {
95449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95450       };
95451     }
95452   }
95453
95454   jresult = (void *)result;
95455   return jresult;
95456 }
95457
95458
95459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95460   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95461
95462   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95463   {
95464     try {
95465       delete arg1;
95466     } catch (std::out_of_range& e) {
95467       {
95468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95469       };
95470     } catch (std::exception& e) {
95471       {
95472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95473       };
95474     } catch (Dali::DaliException e) {
95475       {
95476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95477       };
95478     } catch (...) {
95479       {
95480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95481       };
95482     }
95483   }
95484
95485 }
95486
95487
95488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95489   unsigned int jresult ;
95490   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95491   bool result;
95492
95493   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95494   {
95495     try {
95496       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95497     } catch (std::out_of_range& e) {
95498       {
95499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95500       };
95501     } catch (std::exception& e) {
95502       {
95503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95504       };
95505     } catch (Dali::DaliException e) {
95506       {
95507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95508       };
95509     } catch (...) {
95510       {
95511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95512       };
95513     }
95514   }
95515
95516   jresult = result;
95517   return jresult;
95518 }
95519
95520
95521 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95522   unsigned long jresult ;
95523   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95524   std::size_t result;
95525
95526   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95527   {
95528     try {
95529       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95530     } catch (std::out_of_range& e) {
95531       {
95532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95533       };
95534     } catch (std::exception& e) {
95535       {
95536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95537       };
95538     } catch (Dali::DaliException e) {
95539       {
95540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95541       };
95542     } catch (...) {
95543       {
95544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95545       };
95546     }
95547   }
95548
95549   jresult = (unsigned long)result;
95550   return jresult;
95551 }
95552
95553
95554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95555   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95556   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95557
95558   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95559   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95560   {
95561     try {
95562       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95563     } catch (std::out_of_range& e) {
95564       {
95565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95566       };
95567     } catch (std::exception& e) {
95568       {
95569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95570       };
95571     } catch (Dali::DaliException e) {
95572       {
95573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95574       };
95575     } catch (...) {
95576       {
95577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95578       };
95579     }
95580   }
95581
95582 }
95583
95584
95585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95586   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95587   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95588
95589   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95590   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95591   {
95592     try {
95593       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95594     } catch (std::out_of_range& e) {
95595       {
95596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95597       };
95598     } catch (std::exception& e) {
95599       {
95600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95601       };
95602     } catch (Dali::DaliException e) {
95603       {
95604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95605       };
95606     } catch (...) {
95607       {
95608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95609       };
95610     }
95611   }
95612
95613 }
95614
95615
95616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95617   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95618   Dali::Actor arg2 ;
95619   Dali::Actor arg3 ;
95620   Dali::Actor *argp2 ;
95621   Dali::Actor *argp3 ;
95622
95623   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95624   argp2 = (Dali::Actor *)jarg2;
95625   if (!argp2) {
95626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95627     return ;
95628   }
95629   arg2 = *argp2;
95630   argp3 = (Dali::Actor *)jarg3;
95631   if (!argp3) {
95632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95633     return ;
95634   }
95635   arg3 = *argp3;
95636   {
95637     try {
95638       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95639     } catch (std::out_of_range& e) {
95640       {
95641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95642       };
95643     } catch (std::exception& e) {
95644       {
95645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95646       };
95647     } catch (Dali::DaliException e) {
95648       {
95649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95650       };
95651     } catch (...) {
95652       {
95653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95654       };
95655     }
95656   }
95657
95658 }
95659
95660
95661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95662   void * jresult ;
95663   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95664
95665   {
95666     try {
95667       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95668     } catch (std::out_of_range& e) {
95669       {
95670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95671       };
95672     } catch (std::exception& e) {
95673       {
95674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95675       };
95676     } catch (Dali::DaliException e) {
95677       {
95678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95679       };
95680     } catch (...) {
95681       {
95682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95683       };
95684     }
95685   }
95686
95687   jresult = (void *)result;
95688   return jresult;
95689 }
95690
95691
95692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95693   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95694
95695   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95696   {
95697     try {
95698       delete arg1;
95699     } catch (std::out_of_range& e) {
95700       {
95701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95702       };
95703     } catch (std::exception& e) {
95704       {
95705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95706       };
95707     } catch (Dali::DaliException e) {
95708       {
95709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95710       };
95711     } catch (...) {
95712       {
95713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95714       };
95715     }
95716   }
95717
95718 }
95719
95720
95721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95722   unsigned int jresult ;
95723   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95724   bool result;
95725
95726   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95727   {
95728     try {
95729       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95730     } catch (std::out_of_range& e) {
95731       {
95732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95733       };
95734     } catch (std::exception& e) {
95735       {
95736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95737       };
95738     } catch (Dali::DaliException e) {
95739       {
95740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95741       };
95742     } catch (...) {
95743       {
95744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95745       };
95746     }
95747   }
95748
95749   jresult = result;
95750   return jresult;
95751 }
95752
95753
95754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95755   unsigned long jresult ;
95756   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95757   std::size_t result;
95758
95759   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95760   {
95761     try {
95762       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95763     } catch (std::out_of_range& e) {
95764       {
95765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95766       };
95767     } catch (std::exception& e) {
95768       {
95769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95770       };
95771     } catch (Dali::DaliException e) {
95772       {
95773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95774       };
95775     } catch (...) {
95776       {
95777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95778       };
95779     }
95780   }
95781
95782   jresult = (unsigned long)result;
95783   return jresult;
95784 }
95785
95786
95787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95788   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95789   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95790
95791   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95792   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95793   {
95794     try {
95795       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95796     } catch (std::out_of_range& e) {
95797       {
95798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95799       };
95800     } catch (std::exception& e) {
95801       {
95802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95803       };
95804     } catch (Dali::DaliException e) {
95805       {
95806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95807       };
95808     } catch (...) {
95809       {
95810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95811       };
95812     }
95813   }
95814
95815 }
95816
95817
95818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95819   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95820   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95821
95822   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95823   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95824   {
95825     try {
95826       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95827     } catch (std::out_of_range& e) {
95828       {
95829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95830       };
95831     } catch (std::exception& e) {
95832       {
95833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95834       };
95835     } catch (Dali::DaliException e) {
95836       {
95837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95838       };
95839     } catch (...) {
95840       {
95841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95842       };
95843     }
95844   }
95845
95846 }
95847
95848
95849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95850   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95851   Dali::Actor arg2 ;
95852   bool arg3 ;
95853   Dali::Actor *argp2 ;
95854
95855   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95856   argp2 = (Dali::Actor *)jarg2;
95857   if (!argp2) {
95858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95859     return ;
95860   }
95861   arg2 = *argp2;
95862   arg3 = jarg3 ? true : false;
95863   {
95864     try {
95865       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95866     } catch (std::out_of_range& e) {
95867       {
95868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95869       };
95870     } catch (std::exception& e) {
95871       {
95872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95873       };
95874     } catch (Dali::DaliException e) {
95875       {
95876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95877       };
95878     } catch (...) {
95879       {
95880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95881       };
95882     }
95883   }
95884
95885 }
95886
95887
95888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95889   void * jresult ;
95890   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95891
95892   {
95893     try {
95894       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95895     } catch (std::out_of_range& e) {
95896       {
95897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95898       };
95899     } catch (std::exception& e) {
95900       {
95901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95902       };
95903     } catch (Dali::DaliException e) {
95904       {
95905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95906       };
95907     } catch (...) {
95908       {
95909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95910       };
95911     }
95912   }
95913
95914   jresult = (void *)result;
95915   return jresult;
95916 }
95917
95918
95919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95920   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95921
95922   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95923   {
95924     try {
95925       delete arg1;
95926     } catch (std::out_of_range& e) {
95927       {
95928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95929       };
95930     } catch (std::exception& e) {
95931       {
95932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95933       };
95934     } catch (Dali::DaliException e) {
95935       {
95936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95937       };
95938     } catch (...) {
95939       {
95940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95941       };
95942     }
95943   }
95944
95945 }
95946
95947
95948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95949   unsigned int jresult ;
95950   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95951   bool result;
95952
95953   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95954   {
95955     try {
95956       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);
95957     } catch (std::out_of_range& e) {
95958       {
95959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95960       };
95961     } catch (std::exception& e) {
95962       {
95963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95964       };
95965     } catch (Dali::DaliException e) {
95966       {
95967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95968       };
95969     } catch (...) {
95970       {
95971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95972       };
95973     }
95974   }
95975
95976   jresult = result;
95977   return jresult;
95978 }
95979
95980
95981 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95982   unsigned long jresult ;
95983   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95984   std::size_t result;
95985
95986   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95987   {
95988     try {
95989       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);
95990     } catch (std::out_of_range& e) {
95991       {
95992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95993       };
95994     } catch (std::exception& e) {
95995       {
95996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95997       };
95998     } catch (Dali::DaliException e) {
95999       {
96000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96001       };
96002     } catch (...) {
96003       {
96004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96005       };
96006     }
96007   }
96008
96009   jresult = (unsigned long)result;
96010   return jresult;
96011 }
96012
96013
96014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96015   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96016   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96017
96018   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96019   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96020   {
96021     try {
96022       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96023     } catch (std::out_of_range& e) {
96024       {
96025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96026       };
96027     } catch (std::exception& e) {
96028       {
96029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96030       };
96031     } catch (Dali::DaliException e) {
96032       {
96033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96034       };
96035     } catch (...) {
96036       {
96037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96038       };
96039     }
96040   }
96041
96042 }
96043
96044
96045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96046   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96047   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96048
96049   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96050   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96051   {
96052     try {
96053       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96054     } catch (std::out_of_range& e) {
96055       {
96056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96057       };
96058     } catch (std::exception& e) {
96059       {
96060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96061       };
96062     } catch (Dali::DaliException e) {
96063       {
96064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96065       };
96066     } catch (...) {
96067       {
96068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96069       };
96070     }
96071   }
96072
96073 }
96074
96075
96076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96077   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96078   Dali::Toolkit::StyleManager arg2 ;
96079   Dali::StyleChange::Type arg3 ;
96080   Dali::Toolkit::StyleManager *argp2 ;
96081
96082   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96083   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96084   if (!argp2) {
96085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96086     return ;
96087   }
96088   arg2 = *argp2;
96089   arg3 = (Dali::StyleChange::Type)jarg3;
96090   {
96091     try {
96092       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96093     } catch (std::out_of_range& e) {
96094       {
96095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96096       };
96097     } catch (std::exception& e) {
96098       {
96099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96100       };
96101     } catch (Dali::DaliException e) {
96102       {
96103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96104       };
96105     } catch (...) {
96106       {
96107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96108       };
96109     }
96110   }
96111
96112 }
96113
96114
96115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96116   void * jresult ;
96117   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96118
96119   {
96120     try {
96121       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96122     } catch (std::out_of_range& e) {
96123       {
96124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96125       };
96126     } catch (std::exception& e) {
96127       {
96128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96129       };
96130     } catch (Dali::DaliException e) {
96131       {
96132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96133       };
96134     } catch (...) {
96135       {
96136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96137       };
96138     }
96139   }
96140
96141   jresult = (void *)result;
96142   return jresult;
96143 }
96144
96145
96146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96147   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96148
96149   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96150   {
96151     try {
96152       delete arg1;
96153     } catch (std::out_of_range& e) {
96154       {
96155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96156       };
96157     } catch (std::exception& e) {
96158       {
96159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96160       };
96161     } catch (Dali::DaliException e) {
96162       {
96163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96164       };
96165     } catch (...) {
96166       {
96167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96168       };
96169     }
96170   }
96171
96172 }
96173
96174
96175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96176   unsigned int jresult ;
96177   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96178   bool result;
96179
96180   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96181   {
96182     try {
96183       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96184     } catch (std::out_of_range& e) {
96185       {
96186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96187       };
96188     } catch (std::exception& e) {
96189       {
96190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96191       };
96192     } catch (Dali::DaliException e) {
96193       {
96194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96195       };
96196     } catch (...) {
96197       {
96198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96199       };
96200     }
96201   }
96202
96203   jresult = result;
96204   return jresult;
96205 }
96206
96207
96208 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96209   unsigned long jresult ;
96210   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96211   std::size_t result;
96212
96213   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96214   {
96215     try {
96216       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96217     } catch (std::out_of_range& e) {
96218       {
96219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96220       };
96221     } catch (std::exception& e) {
96222       {
96223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96224       };
96225     } catch (Dali::DaliException e) {
96226       {
96227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96228       };
96229     } catch (...) {
96230       {
96231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96232       };
96233     }
96234   }
96235
96236   jresult = (unsigned long)result;
96237   return jresult;
96238 }
96239
96240
96241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96242   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96243   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96244
96245   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96246   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96247   {
96248     try {
96249       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96250     } catch (std::out_of_range& e) {
96251       {
96252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96253       };
96254     } catch (std::exception& e) {
96255       {
96256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96257       };
96258     } catch (Dali::DaliException e) {
96259       {
96260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96261       };
96262     } catch (...) {
96263       {
96264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96265       };
96266     }
96267   }
96268
96269 }
96270
96271
96272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96273   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96274   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96275
96276   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96277   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96278   {
96279     try {
96280       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96281     } catch (std::out_of_range& e) {
96282       {
96283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96284       };
96285     } catch (std::exception& e) {
96286       {
96287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96288       };
96289     } catch (Dali::DaliException e) {
96290       {
96291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96292       };
96293     } catch (...) {
96294       {
96295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96296       };
96297     }
96298   }
96299
96300 }
96301
96302
96303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96304   unsigned int jresult ;
96305   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96306   Dali::Toolkit::Button arg2 ;
96307   Dali::Toolkit::Button *argp2 ;
96308   bool result;
96309
96310   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96311   argp2 = (Dali::Toolkit::Button *)jarg2;
96312   if (!argp2) {
96313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96314     return 0;
96315   }
96316   arg2 = *argp2;
96317   {
96318     try {
96319       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96320     } catch (std::out_of_range& e) {
96321       {
96322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96323       };
96324     } catch (std::exception& e) {
96325       {
96326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96327       };
96328     } catch (Dali::DaliException e) {
96329       {
96330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96331       };
96332     } catch (...) {
96333       {
96334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96335       };
96336     }
96337   }
96338
96339   jresult = result;
96340   return jresult;
96341 }
96342
96343
96344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96345   void * jresult ;
96346   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96347
96348   {
96349     try {
96350       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96351     } catch (std::out_of_range& e) {
96352       {
96353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96354       };
96355     } catch (std::exception& e) {
96356       {
96357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96358       };
96359     } catch (Dali::DaliException e) {
96360       {
96361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96362       };
96363     } catch (...) {
96364       {
96365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96366       };
96367     }
96368   }
96369
96370   jresult = (void *)result;
96371   return jresult;
96372 }
96373
96374
96375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96376   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96377
96378   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96379   {
96380     try {
96381       delete arg1;
96382     } catch (std::out_of_range& e) {
96383       {
96384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96385       };
96386     } catch (std::exception& e) {
96387       {
96388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96389       };
96390     } catch (Dali::DaliException e) {
96391       {
96392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96393       };
96394     } catch (...) {
96395       {
96396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96397       };
96398     }
96399   }
96400
96401 }
96402
96403
96404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96405   unsigned int jresult ;
96406   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96407   bool result;
96408
96409   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96410   {
96411     try {
96412       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96413     } catch (std::out_of_range& e) {
96414       {
96415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96416       };
96417     } catch (std::exception& e) {
96418       {
96419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96420       };
96421     } catch (Dali::DaliException e) {
96422       {
96423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96424       };
96425     } catch (...) {
96426       {
96427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96428       };
96429     }
96430   }
96431
96432   jresult = result;
96433   return jresult;
96434 }
96435
96436
96437 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96438   unsigned long jresult ;
96439   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96440   std::size_t result;
96441
96442   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96443   {
96444     try {
96445       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96446     } catch (std::out_of_range& e) {
96447       {
96448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96449       };
96450     } catch (std::exception& e) {
96451       {
96452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96453       };
96454     } catch (Dali::DaliException e) {
96455       {
96456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96457       };
96458     } catch (...) {
96459       {
96460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96461       };
96462     }
96463   }
96464
96465   jresult = (unsigned long)result;
96466   return jresult;
96467 }
96468
96469
96470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96471   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96472   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96473
96474   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96475   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96476   {
96477     try {
96478       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96479     } catch (std::out_of_range& e) {
96480       {
96481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96482       };
96483     } catch (std::exception& e) {
96484       {
96485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96486       };
96487     } catch (Dali::DaliException e) {
96488       {
96489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96490       };
96491     } catch (...) {
96492       {
96493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96494       };
96495     }
96496   }
96497
96498 }
96499
96500
96501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96502   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96503   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96504
96505   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96506   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96507   {
96508     try {
96509       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96510     } catch (std::out_of_range& e) {
96511       {
96512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96513       };
96514     } catch (std::exception& e) {
96515       {
96516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96517       };
96518     } catch (Dali::DaliException e) {
96519       {
96520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96521       };
96522     } catch (...) {
96523       {
96524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96525       };
96526     }
96527   }
96528
96529 }
96530
96531
96532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96533   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96534   Dali::Toolkit::GaussianBlurView arg2 ;
96535   Dali::Toolkit::GaussianBlurView *argp2 ;
96536
96537   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96538   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96539   if (!argp2) {
96540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96541     return ;
96542   }
96543   arg2 = *argp2;
96544   {
96545     try {
96546       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96547     } catch (std::out_of_range& e) {
96548       {
96549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96550       };
96551     } catch (std::exception& e) {
96552       {
96553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96554       };
96555     } catch (Dali::DaliException e) {
96556       {
96557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96558       };
96559     } catch (...) {
96560       {
96561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96562       };
96563     }
96564   }
96565
96566 }
96567
96568
96569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96570   void * jresult ;
96571   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96572
96573   {
96574     try {
96575       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96576     } catch (std::out_of_range& e) {
96577       {
96578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96579       };
96580     } catch (std::exception& e) {
96581       {
96582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96583       };
96584     } catch (Dali::DaliException e) {
96585       {
96586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96587       };
96588     } catch (...) {
96589       {
96590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96591       };
96592     }
96593   }
96594
96595   jresult = (void *)result;
96596   return jresult;
96597 }
96598
96599
96600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96601   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96602
96603   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96604   {
96605     try {
96606       delete arg1;
96607     } catch (std::out_of_range& e) {
96608       {
96609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96610       };
96611     } catch (std::exception& e) {
96612       {
96613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96614       };
96615     } catch (Dali::DaliException e) {
96616       {
96617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96618       };
96619     } catch (...) {
96620       {
96621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96622       };
96623     }
96624   }
96625
96626 }
96627
96628
96629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96630   unsigned int jresult ;
96631   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96632   bool result;
96633
96634   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96635   {
96636     try {
96637       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);
96638     } catch (std::out_of_range& e) {
96639       {
96640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96641       };
96642     } catch (std::exception& e) {
96643       {
96644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96645       };
96646     } catch (Dali::DaliException e) {
96647       {
96648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96649       };
96650     } catch (...) {
96651       {
96652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96653       };
96654     }
96655   }
96656
96657   jresult = result;
96658   return jresult;
96659 }
96660
96661
96662 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96663   unsigned long jresult ;
96664   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96665   std::size_t result;
96666
96667   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96668   {
96669     try {
96670       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);
96671     } catch (std::out_of_range& e) {
96672       {
96673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96674       };
96675     } catch (std::exception& e) {
96676       {
96677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96678       };
96679     } catch (Dali::DaliException e) {
96680       {
96681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96682       };
96683     } catch (...) {
96684       {
96685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96686       };
96687     }
96688   }
96689
96690   jresult = (unsigned long)result;
96691   return jresult;
96692 }
96693
96694
96695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96696   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96697   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96698
96699   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96700   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96701   {
96702     try {
96703       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96704     } catch (std::out_of_range& e) {
96705       {
96706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96707       };
96708     } catch (std::exception& e) {
96709       {
96710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96711       };
96712     } catch (Dali::DaliException e) {
96713       {
96714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96715       };
96716     } catch (...) {
96717       {
96718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96719       };
96720     }
96721   }
96722
96723 }
96724
96725
96726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96727   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96728   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96729
96730   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96731   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96732   {
96733     try {
96734       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96735     } catch (std::out_of_range& e) {
96736       {
96737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96738       };
96739     } catch (std::exception& e) {
96740       {
96741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96742       };
96743     } catch (Dali::DaliException e) {
96744       {
96745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96746       };
96747     } catch (...) {
96748       {
96749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96750       };
96751     }
96752   }
96753
96754 }
96755
96756
96757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96758   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96759   Dali::Toolkit::PageTurnView arg2 ;
96760   unsigned int arg3 ;
96761   bool arg4 ;
96762   Dali::Toolkit::PageTurnView *argp2 ;
96763
96764   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96765   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96766   if (!argp2) {
96767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96768     return ;
96769   }
96770   arg2 = *argp2;
96771   arg3 = (unsigned int)jarg3;
96772   arg4 = jarg4 ? true : false;
96773   {
96774     try {
96775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96776     } catch (std::out_of_range& e) {
96777       {
96778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96779       };
96780     } catch (std::exception& e) {
96781       {
96782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96783       };
96784     } catch (Dali::DaliException e) {
96785       {
96786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96787       };
96788     } catch (...) {
96789       {
96790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96791       };
96792     }
96793   }
96794
96795 }
96796
96797
96798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96799   void * jresult ;
96800   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96801
96802   {
96803     try {
96804       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96805     } catch (std::out_of_range& e) {
96806       {
96807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96808       };
96809     } catch (std::exception& e) {
96810       {
96811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96812       };
96813     } catch (Dali::DaliException e) {
96814       {
96815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96816       };
96817     } catch (...) {
96818       {
96819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96820       };
96821     }
96822   }
96823
96824   jresult = (void *)result;
96825   return jresult;
96826 }
96827
96828
96829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96830   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96831
96832   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96833   {
96834     try {
96835       delete arg1;
96836     } catch (std::out_of_range& e) {
96837       {
96838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96839       };
96840     } catch (std::exception& e) {
96841       {
96842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96843       };
96844     } catch (Dali::DaliException e) {
96845       {
96846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96847       };
96848     } catch (...) {
96849       {
96850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96851       };
96852     }
96853   }
96854
96855 }
96856
96857
96858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96859   unsigned int jresult ;
96860   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96861   bool result;
96862
96863   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96864   {
96865     try {
96866       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96867     } catch (std::out_of_range& e) {
96868       {
96869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96870       };
96871     } catch (std::exception& e) {
96872       {
96873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96874       };
96875     } catch (Dali::DaliException e) {
96876       {
96877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96878       };
96879     } catch (...) {
96880       {
96881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96882       };
96883     }
96884   }
96885
96886   jresult = result;
96887   return jresult;
96888 }
96889
96890
96891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96892   unsigned long jresult ;
96893   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96894   std::size_t result;
96895
96896   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96897   {
96898     try {
96899       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96900     } catch (std::out_of_range& e) {
96901       {
96902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96903       };
96904     } catch (std::exception& e) {
96905       {
96906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96907       };
96908     } catch (Dali::DaliException e) {
96909       {
96910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96911       };
96912     } catch (...) {
96913       {
96914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96915       };
96916     }
96917   }
96918
96919   jresult = (unsigned long)result;
96920   return jresult;
96921 }
96922
96923
96924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96925   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96926   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96927
96928   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96929   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96930   {
96931     try {
96932       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96933     } catch (std::out_of_range& e) {
96934       {
96935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96936       };
96937     } catch (std::exception& e) {
96938       {
96939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96940       };
96941     } catch (Dali::DaliException e) {
96942       {
96943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96944       };
96945     } catch (...) {
96946       {
96947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96948       };
96949     }
96950   }
96951
96952 }
96953
96954
96955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96956   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96957   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96958
96959   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96960   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96961   {
96962     try {
96963       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96964     } catch (std::out_of_range& e) {
96965       {
96966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96967       };
96968     } catch (std::exception& e) {
96969       {
96970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96971       };
96972     } catch (Dali::DaliException e) {
96973       {
96974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96975       };
96976     } catch (...) {
96977       {
96978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96979       };
96980     }
96981   }
96982
96983 }
96984
96985
96986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96987   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96988   Dali::Toolkit::PageTurnView arg2 ;
96989   Dali::Toolkit::PageTurnView *argp2 ;
96990
96991   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96992   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96993   if (!argp2) {
96994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96995     return ;
96996   }
96997   arg2 = *argp2;
96998   {
96999     try {
97000       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97001     } catch (std::out_of_range& e) {
97002       {
97003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97004       };
97005     } catch (std::exception& e) {
97006       {
97007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97008       };
97009     } catch (Dali::DaliException e) {
97010       {
97011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97012       };
97013     } catch (...) {
97014       {
97015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97016       };
97017     }
97018   }
97019
97020 }
97021
97022
97023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97024   void * jresult ;
97025   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97026
97027   {
97028     try {
97029       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97030     } catch (std::out_of_range& e) {
97031       {
97032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97033       };
97034     } catch (std::exception& e) {
97035       {
97036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97037       };
97038     } catch (Dali::DaliException e) {
97039       {
97040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97041       };
97042     } catch (...) {
97043       {
97044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97045       };
97046     }
97047   }
97048
97049   jresult = (void *)result;
97050   return jresult;
97051 }
97052
97053
97054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97055   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97056
97057   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97058   {
97059     try {
97060       delete arg1;
97061     } catch (std::out_of_range& e) {
97062       {
97063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97064       };
97065     } catch (std::exception& e) {
97066       {
97067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97068       };
97069     } catch (Dali::DaliException e) {
97070       {
97071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97072       };
97073     } catch (...) {
97074       {
97075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97076       };
97077     }
97078   }
97079
97080 }
97081
97082
97083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97084   unsigned int jresult ;
97085   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97086   bool result;
97087
97088   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97089   {
97090     try {
97091       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);
97092     } catch (std::out_of_range& e) {
97093       {
97094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97095       };
97096     } catch (std::exception& e) {
97097       {
97098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97099       };
97100     } catch (Dali::DaliException e) {
97101       {
97102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97103       };
97104     } catch (...) {
97105       {
97106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97107       };
97108     }
97109   }
97110
97111   jresult = result;
97112   return jresult;
97113 }
97114
97115
97116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97117   unsigned long jresult ;
97118   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97119   std::size_t result;
97120
97121   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97122   {
97123     try {
97124       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);
97125     } catch (std::out_of_range& e) {
97126       {
97127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97128       };
97129     } catch (std::exception& e) {
97130       {
97131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97132       };
97133     } catch (Dali::DaliException e) {
97134       {
97135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97136       };
97137     } catch (...) {
97138       {
97139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97140       };
97141     }
97142   }
97143
97144   jresult = (unsigned long)result;
97145   return jresult;
97146 }
97147
97148
97149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97150   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97151   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97152
97153   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97154   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97155   {
97156     try {
97157       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97158     } catch (std::out_of_range& e) {
97159       {
97160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97161       };
97162     } catch (std::exception& e) {
97163       {
97164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97165       };
97166     } catch (Dali::DaliException e) {
97167       {
97168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97169       };
97170     } catch (...) {
97171       {
97172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97173       };
97174     }
97175   }
97176
97177 }
97178
97179
97180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97181   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97182   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97183
97184   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97185   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97186   {
97187     try {
97188       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97189     } catch (std::out_of_range& e) {
97190       {
97191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97192       };
97193     } catch (std::exception& e) {
97194       {
97195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97196       };
97197     } catch (Dali::DaliException e) {
97198       {
97199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97200       };
97201     } catch (...) {
97202       {
97203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97204       };
97205     }
97206   }
97207
97208 }
97209
97210
97211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97212   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97213   Dali::Toolkit::ProgressBar arg2 ;
97214   float arg3 ;
97215   float arg4 ;
97216   Dali::Toolkit::ProgressBar *argp2 ;
97217
97218   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97219   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97220   if (!argp2) {
97221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97222     return ;
97223   }
97224   arg2 = *argp2;
97225   arg3 = (float)jarg3;
97226   arg4 = (float)jarg4;
97227   {
97228     try {
97229       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97230     } catch (std::out_of_range& e) {
97231       {
97232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97233       };
97234     } catch (std::exception& e) {
97235       {
97236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97237       };
97238     } catch (Dali::DaliException e) {
97239       {
97240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97241       };
97242     } catch (...) {
97243       {
97244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97245       };
97246     }
97247   }
97248
97249 }
97250
97251
97252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97253   void * jresult ;
97254   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97255
97256   {
97257     try {
97258       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97259     } catch (std::out_of_range& e) {
97260       {
97261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97262       };
97263     } catch (std::exception& e) {
97264       {
97265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97266       };
97267     } catch (Dali::DaliException e) {
97268       {
97269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97270       };
97271     } catch (...) {
97272       {
97273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97274       };
97275     }
97276   }
97277
97278   jresult = (void *)result;
97279   return jresult;
97280 }
97281
97282
97283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97284   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97285
97286   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97287   {
97288     try {
97289       delete arg1;
97290     } catch (std::out_of_range& e) {
97291       {
97292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97293       };
97294     } catch (std::exception& e) {
97295       {
97296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97297       };
97298     } catch (Dali::DaliException e) {
97299       {
97300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97301       };
97302     } catch (...) {
97303       {
97304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97305       };
97306     }
97307   }
97308
97309 }
97310
97311
97312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97313   unsigned int jresult ;
97314   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97315   bool result;
97316
97317   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97318   {
97319     try {
97320       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);
97321     } catch (std::out_of_range& e) {
97322       {
97323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97324       };
97325     } catch (std::exception& e) {
97326       {
97327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97328       };
97329     } catch (Dali::DaliException e) {
97330       {
97331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97332       };
97333     } catch (...) {
97334       {
97335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97336       };
97337     }
97338   }
97339
97340   jresult = result;
97341   return jresult;
97342 }
97343
97344
97345 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97346   unsigned long jresult ;
97347   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97348   std::size_t result;
97349
97350   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97351   {
97352     try {
97353       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);
97354     } catch (std::out_of_range& e) {
97355       {
97356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97357       };
97358     } catch (std::exception& e) {
97359       {
97360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97361       };
97362     } catch (Dali::DaliException e) {
97363       {
97364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97365       };
97366     } catch (...) {
97367       {
97368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97369       };
97370     }
97371   }
97372
97373   jresult = (unsigned long)result;
97374   return jresult;
97375 }
97376
97377
97378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97379   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97380   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97381
97382   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97383   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97384   {
97385     try {
97386       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97387     } catch (std::out_of_range& e) {
97388       {
97389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97390       };
97391     } catch (std::exception& e) {
97392       {
97393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97394       };
97395     } catch (Dali::DaliException e) {
97396       {
97397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97398       };
97399     } catch (...) {
97400       {
97401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97402       };
97403     }
97404   }
97405
97406 }
97407
97408
97409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97410   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97411   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97412
97413   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97414   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97415   {
97416     try {
97417       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97418     } catch (std::out_of_range& e) {
97419       {
97420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97421       };
97422     } catch (std::exception& e) {
97423       {
97424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97425       };
97426     } catch (Dali::DaliException e) {
97427       {
97428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97429       };
97430     } catch (...) {
97431       {
97432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97433       };
97434     }
97435   }
97436
97437 }
97438
97439
97440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97441   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97442   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97443
97444   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97445   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97446   if (!arg2) {
97447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97448     return ;
97449   }
97450   {
97451     try {
97452       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97453     } catch (std::out_of_range& e) {
97454       {
97455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97456       };
97457     } catch (std::exception& e) {
97458       {
97459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97460       };
97461     } catch (Dali::DaliException e) {
97462       {
97463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97464       };
97465     } catch (...) {
97466       {
97467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97468       };
97469     }
97470   }
97471
97472 }
97473
97474
97475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97476   void * jresult ;
97477   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97478
97479   {
97480     try {
97481       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97482     } catch (std::out_of_range& e) {
97483       {
97484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97485       };
97486     } catch (std::exception& e) {
97487       {
97488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97489       };
97490     } catch (Dali::DaliException e) {
97491       {
97492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97493       };
97494     } catch (...) {
97495       {
97496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97497       };
97498     }
97499   }
97500
97501   jresult = (void *)result;
97502   return jresult;
97503 }
97504
97505
97506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97507   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97508
97509   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97510   {
97511     try {
97512       delete arg1;
97513     } catch (std::out_of_range& e) {
97514       {
97515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97516       };
97517     } catch (std::exception& e) {
97518       {
97519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97520       };
97521     } catch (Dali::DaliException e) {
97522       {
97523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97524       };
97525     } catch (...) {
97526       {
97527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97528       };
97529     }
97530   }
97531
97532 }
97533
97534
97535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97536   unsigned int jresult ;
97537   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97538   bool result;
97539
97540   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97541   {
97542     try {
97543       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97544     } catch (std::out_of_range& e) {
97545       {
97546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97547       };
97548     } catch (std::exception& e) {
97549       {
97550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97551       };
97552     } catch (Dali::DaliException e) {
97553       {
97554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97555       };
97556     } catch (...) {
97557       {
97558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97559       };
97560     }
97561   }
97562
97563   jresult = result;
97564   return jresult;
97565 }
97566
97567
97568 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97569   unsigned long jresult ;
97570   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97571   std::size_t result;
97572
97573   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97574   {
97575     try {
97576       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97577     } catch (std::out_of_range& e) {
97578       {
97579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97580       };
97581     } catch (std::exception& e) {
97582       {
97583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97584       };
97585     } catch (Dali::DaliException e) {
97586       {
97587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97588       };
97589     } catch (...) {
97590       {
97591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97592       };
97593     }
97594   }
97595
97596   jresult = (unsigned long)result;
97597   return jresult;
97598 }
97599
97600
97601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97602   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97603   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97604
97605   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97606   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97607   {
97608     try {
97609       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97610     } catch (std::out_of_range& e) {
97611       {
97612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97613       };
97614     } catch (std::exception& e) {
97615       {
97616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97617       };
97618     } catch (Dali::DaliException e) {
97619       {
97620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97621       };
97622     } catch (...) {
97623       {
97624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97625       };
97626     }
97627   }
97628
97629 }
97630
97631
97632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97633   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97634   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97635
97636   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97637   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97638   {
97639     try {
97640       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97641     } catch (std::out_of_range& e) {
97642       {
97643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97644       };
97645     } catch (std::exception& e) {
97646       {
97647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97648       };
97649     } catch (Dali::DaliException e) {
97650       {
97651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97652       };
97653     } catch (...) {
97654       {
97655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97656       };
97657     }
97658   }
97659
97660 }
97661
97662
97663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97664   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97665   Dali::Vector2 *arg2 = 0 ;
97666
97667   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97668   arg2 = (Dali::Vector2 *)jarg2;
97669   if (!arg2) {
97670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97671     return ;
97672   }
97673   {
97674     try {
97675       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97676     } catch (std::out_of_range& e) {
97677       {
97678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97679       };
97680     } catch (std::exception& e) {
97681       {
97682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97683       };
97684     } catch (Dali::DaliException e) {
97685       {
97686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97687       };
97688     } catch (...) {
97689       {
97690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97691       };
97692     }
97693   }
97694
97695 }
97696
97697
97698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97699   void * jresult ;
97700   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97701
97702   {
97703     try {
97704       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97705     } catch (std::out_of_range& e) {
97706       {
97707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97708       };
97709     } catch (std::exception& e) {
97710       {
97711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97712       };
97713     } catch (Dali::DaliException e) {
97714       {
97715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97716       };
97717     } catch (...) {
97718       {
97719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97720       };
97721     }
97722   }
97723
97724   jresult = (void *)result;
97725   return jresult;
97726 }
97727
97728
97729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97730   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97731
97732   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97733   {
97734     try {
97735       delete arg1;
97736     } catch (std::out_of_range& e) {
97737       {
97738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97739       };
97740     } catch (std::exception& e) {
97741       {
97742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97743       };
97744     } catch (Dali::DaliException e) {
97745       {
97746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97747       };
97748     } catch (...) {
97749       {
97750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97751       };
97752     }
97753   }
97754
97755 }
97756
97757
97758
97759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97760   unsigned int jresult ;
97761   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97762   bool result;
97763
97764   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97765   {
97766     try {
97767       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);
97768     } catch (std::out_of_range& e) {
97769       {
97770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97771       };
97772     } catch (std::exception& e) {
97773       {
97774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97775       };
97776     } catch (Dali::DaliException e) {
97777       {
97778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97779       };
97780     } catch (...) {
97781       {
97782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97783       };
97784     }
97785   }
97786
97787   jresult = result;
97788   return jresult;
97789 }
97790
97791
97792 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97793   unsigned long jresult ;
97794   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97795   std::size_t result;
97796
97797   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97798   {
97799     try {
97800       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);
97801     } catch (std::out_of_range& e) {
97802       {
97803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97804       };
97805     } catch (std::exception& e) {
97806       {
97807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97808       };
97809     } catch (Dali::DaliException e) {
97810       {
97811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97812       };
97813     } catch (...) {
97814       {
97815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97816       };
97817     }
97818   }
97819
97820   jresult = (unsigned long)result;
97821   return jresult;
97822 }
97823
97824
97825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97826   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97827   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97828
97829   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97830   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97831   {
97832     try {
97833       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97834     } catch (std::out_of_range& e) {
97835       {
97836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97837       };
97838     } catch (std::exception& e) {
97839       {
97840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97841       };
97842     } catch (Dali::DaliException e) {
97843       {
97844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97845       };
97846     } catch (...) {
97847       {
97848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97849       };
97850     }
97851   }
97852
97853 }
97854
97855
97856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97857   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97858   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97859
97860   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97861   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97862   {
97863     try {
97864       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97865     } catch (std::out_of_range& e) {
97866       {
97867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97868       };
97869     } catch (std::exception& e) {
97870       {
97871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97872       };
97873     } catch (Dali::DaliException e) {
97874       {
97875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97876       };
97877     } catch (...) {
97878       {
97879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97880       };
97881     }
97882   }
97883
97884 }
97885
97886
97887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97888   unsigned int jresult ;
97889   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97890   Dali::Toolkit::Control arg2 ;
97891   Dali::KeyEvent *arg3 = 0 ;
97892   Dali::Toolkit::Control *argp2 ;
97893   bool result;
97894
97895   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97896   argp2 = (Dali::Toolkit::Control *)jarg2;
97897   if (!argp2) {
97898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97899     return 0;
97900   }
97901   arg2 = *argp2;
97902   arg3 = (Dali::KeyEvent *)jarg3;
97903   if (!arg3) {
97904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97905     return 0;
97906   }
97907   {
97908     try {
97909       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);
97910     } catch (std::out_of_range& e) {
97911       {
97912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97913       };
97914     } catch (std::exception& e) {
97915       {
97916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97917       };
97918     } catch (Dali::DaliException e) {
97919       {
97920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97921       };
97922     } catch (...) {
97923       {
97924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97925       };
97926     }
97927   }
97928
97929   jresult = result;
97930   return jresult;
97931 }
97932
97933
97934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97935   void * jresult ;
97936   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97937
97938   {
97939     try {
97940       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97941     } catch (std::out_of_range& e) {
97942       {
97943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97944       };
97945     } catch (std::exception& e) {
97946       {
97947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97948       };
97949     } catch (Dali::DaliException e) {
97950       {
97951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97952       };
97953     } catch (...) {
97954       {
97955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97956       };
97957     }
97958   }
97959
97960   jresult = (void *)result;
97961   return jresult;
97962 }
97963
97964
97965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97966   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97967
97968   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97969   {
97970     try {
97971       delete arg1;
97972     } catch (std::out_of_range& e) {
97973       {
97974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97975       };
97976     } catch (std::exception& e) {
97977       {
97978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97979       };
97980     } catch (Dali::DaliException e) {
97981       {
97982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97983       };
97984     } catch (...) {
97985       {
97986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97987       };
97988     }
97989   }
97990
97991 }
97992
97993
97994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97995   unsigned int jresult ;
97996   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97997   bool result;
97998
97999   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98000   {
98001     try {
98002       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98003     } catch (std::out_of_range& e) {
98004       {
98005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98006       };
98007     } catch (std::exception& e) {
98008       {
98009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98010       };
98011     } catch (Dali::DaliException e) {
98012       {
98013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98014       };
98015     } catch (...) {
98016       {
98017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98018       };
98019     }
98020   }
98021
98022   jresult = result;
98023   return jresult;
98024 }
98025
98026
98027 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98028   unsigned long jresult ;
98029   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98030   std::size_t result;
98031
98032   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98033   {
98034     try {
98035       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98036     } catch (std::out_of_range& e) {
98037       {
98038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98039       };
98040     } catch (std::exception& e) {
98041       {
98042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98043       };
98044     } catch (Dali::DaliException e) {
98045       {
98046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98047       };
98048     } catch (...) {
98049       {
98050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98051       };
98052     }
98053   }
98054
98055   jresult = (unsigned long)result;
98056   return jresult;
98057 }
98058
98059
98060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98061   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98062   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98063
98064   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98065   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98066   {
98067     try {
98068       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98069     } catch (std::out_of_range& e) {
98070       {
98071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98072       };
98073     } catch (std::exception& e) {
98074       {
98075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98076       };
98077     } catch (Dali::DaliException e) {
98078       {
98079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98080       };
98081     } catch (...) {
98082       {
98083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98084       };
98085     }
98086   }
98087
98088 }
98089
98090
98091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98092   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98093   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98094
98095   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98096   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98097   {
98098     try {
98099       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98100     } catch (std::out_of_range& e) {
98101       {
98102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98103       };
98104     } catch (std::exception& e) {
98105       {
98106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98107       };
98108     } catch (Dali::DaliException e) {
98109       {
98110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98111       };
98112     } catch (...) {
98113       {
98114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98115       };
98116     }
98117   }
98118
98119 }
98120
98121
98122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98123   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98124   Dali::Toolkit::Control arg2 ;
98125   Dali::Toolkit::Control *argp2 ;
98126
98127   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98128   argp2 = (Dali::Toolkit::Control *)jarg2;
98129   if (!argp2) {
98130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98131     return ;
98132   }
98133   arg2 = *argp2;
98134   {
98135     try {
98136       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98137     } catch (std::out_of_range& e) {
98138       {
98139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98140       };
98141     } catch (std::exception& e) {
98142       {
98143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98144       };
98145     } catch (Dali::DaliException e) {
98146       {
98147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98148       };
98149     } catch (...) {
98150       {
98151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98152       };
98153     }
98154   }
98155
98156 }
98157
98158
98159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98160   void * jresult ;
98161   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98162
98163   {
98164     try {
98165       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98166     } catch (std::out_of_range& e) {
98167       {
98168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98169       };
98170     } catch (std::exception& e) {
98171       {
98172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98173       };
98174     } catch (Dali::DaliException e) {
98175       {
98176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98177       };
98178     } catch (...) {
98179       {
98180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98181       };
98182     }
98183   }
98184
98185   jresult = (void *)result;
98186   return jresult;
98187 }
98188
98189
98190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98191   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98192
98193   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98194   {
98195     try {
98196       delete arg1;
98197     } catch (std::out_of_range& e) {
98198       {
98199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98200       };
98201     } catch (std::exception& e) {
98202       {
98203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98204       };
98205     } catch (Dali::DaliException e) {
98206       {
98207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98208       };
98209     } catch (...) {
98210       {
98211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98212       };
98213     }
98214   }
98215
98216 }
98217
98218
98219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98220   unsigned int jresult ;
98221   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98222   bool result;
98223
98224   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98225   {
98226     try {
98227       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98228     } catch (std::out_of_range& e) {
98229       {
98230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98231       };
98232     } catch (std::exception& e) {
98233       {
98234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98235       };
98236     } catch (Dali::DaliException e) {
98237       {
98238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98239       };
98240     } catch (...) {
98241       {
98242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98243       };
98244     }
98245   }
98246
98247   jresult = result;
98248   return jresult;
98249 }
98250
98251
98252 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98253   unsigned long jresult ;
98254   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98255   std::size_t result;
98256
98257   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98258   {
98259     try {
98260       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98261     } catch (std::out_of_range& e) {
98262       {
98263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98264       };
98265     } catch (std::exception& e) {
98266       {
98267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98268       };
98269     } catch (Dali::DaliException e) {
98270       {
98271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98272       };
98273     } catch (...) {
98274       {
98275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98276       };
98277     }
98278   }
98279
98280   jresult = (unsigned long)result;
98281   return jresult;
98282 }
98283
98284
98285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98286   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98287   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98288
98289   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98290   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98291   {
98292     try {
98293       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98294     } catch (std::out_of_range& e) {
98295       {
98296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98297       };
98298     } catch (std::exception& e) {
98299       {
98300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98301       };
98302     } catch (Dali::DaliException e) {
98303       {
98304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98305       };
98306     } catch (...) {
98307       {
98308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98309       };
98310     }
98311   }
98312
98313 }
98314
98315
98316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98317   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98318   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98319
98320   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98321   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98322   {
98323     try {
98324       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98325     } catch (std::out_of_range& e) {
98326       {
98327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98328       };
98329     } catch (std::exception& e) {
98330       {
98331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98332       };
98333     } catch (Dali::DaliException e) {
98334       {
98335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98336       };
98337     } catch (...) {
98338       {
98339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98340       };
98341     }
98342   }
98343
98344 }
98345
98346
98347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98348   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98349   Dali::Toolkit::VideoView *arg2 = 0 ;
98350
98351   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98352   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98353   if (!arg2) {
98354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98355     return ;
98356   }
98357   {
98358     try {
98359       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98360     } catch (std::out_of_range& e) {
98361       {
98362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98363       };
98364     } catch (std::exception& e) {
98365       {
98366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98367       };
98368     } catch (Dali::DaliException e) {
98369       {
98370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98371       };
98372     } catch (...) {
98373       {
98374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98375       };
98376     }
98377   }
98378
98379 }
98380
98381
98382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98383   void * jresult ;
98384   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98385
98386   {
98387     try {
98388       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98389     } catch (std::out_of_range& e) {
98390       {
98391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98392       };
98393     } catch (std::exception& e) {
98394       {
98395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98396       };
98397     } catch (Dali::DaliException e) {
98398       {
98399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98400       };
98401     } catch (...) {
98402       {
98403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98404       };
98405     }
98406   }
98407
98408   jresult = (void *)result;
98409   return jresult;
98410 }
98411
98412
98413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98414   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98415
98416   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98417   {
98418     try {
98419       delete arg1;
98420     } catch (std::out_of_range& e) {
98421       {
98422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98423       };
98424     } catch (std::exception& e) {
98425       {
98426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98427       };
98428     } catch (Dali::DaliException e) {
98429       {
98430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98431       };
98432     } catch (...) {
98433       {
98434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98435       };
98436     }
98437   }
98438
98439 }
98440
98441
98442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98443   unsigned int jresult ;
98444   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98445   bool result;
98446
98447   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98448   {
98449     try {
98450       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98451     } catch (std::out_of_range& e) {
98452       {
98453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98454       };
98455     } catch (std::exception& e) {
98456       {
98457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98458       };
98459     } catch (Dali::DaliException e) {
98460       {
98461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98462       };
98463     } catch (...) {
98464       {
98465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98466       };
98467     }
98468   }
98469
98470   jresult = result;
98471   return jresult;
98472 }
98473
98474
98475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98476   unsigned long jresult ;
98477   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98478   std::size_t result;
98479
98480   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98481   {
98482     try {
98483       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98484     } catch (std::out_of_range& e) {
98485       {
98486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98487       };
98488     } catch (std::exception& e) {
98489       {
98490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98491       };
98492     } catch (Dali::DaliException e) {
98493       {
98494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98495       };
98496     } catch (...) {
98497       {
98498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98499       };
98500     }
98501   }
98502
98503   jresult = (unsigned long)result;
98504   return jresult;
98505 }
98506
98507
98508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98509   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98510   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98511
98512   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98513   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98514   {
98515     try {
98516       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98517     } catch (std::out_of_range& e) {
98518       {
98519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98520       };
98521     } catch (std::exception& e) {
98522       {
98523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98524       };
98525     } catch (Dali::DaliException e) {
98526       {
98527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98528       };
98529     } catch (...) {
98530       {
98531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98532       };
98533     }
98534   }
98535
98536 }
98537
98538
98539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98540   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98541   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98542
98543   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98544   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98545   {
98546     try {
98547       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98548     } catch (std::out_of_range& e) {
98549       {
98550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98551       };
98552     } catch (std::exception& e) {
98553       {
98554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98555       };
98556     } catch (Dali::DaliException e) {
98557       {
98558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98559       };
98560     } catch (...) {
98561       {
98562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98563       };
98564     }
98565   }
98566
98567 }
98568
98569
98570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98571   unsigned int jresult ;
98572   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98573   Dali::Toolkit::Slider arg2 ;
98574   float arg3 ;
98575   Dali::Toolkit::Slider *argp2 ;
98576   bool result;
98577
98578   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98579   argp2 = (Dali::Toolkit::Slider *)jarg2;
98580   if (!argp2) {
98581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98582     return 0;
98583   }
98584   arg2 = *argp2;
98585   arg3 = (float)jarg3;
98586   {
98587     try {
98588       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98589     } catch (std::out_of_range& e) {
98590       {
98591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98592       };
98593     } catch (std::exception& e) {
98594       {
98595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98596       };
98597     } catch (Dali::DaliException e) {
98598       {
98599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98600       };
98601     } catch (...) {
98602       {
98603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98604       };
98605     }
98606   }
98607
98608   jresult = result;
98609   return jresult;
98610 }
98611
98612
98613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98614   void * jresult ;
98615   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98616
98617   {
98618     try {
98619       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98620     } catch (std::out_of_range& e) {
98621       {
98622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98623       };
98624     } catch (std::exception& e) {
98625       {
98626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98627       };
98628     } catch (Dali::DaliException e) {
98629       {
98630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98631       };
98632     } catch (...) {
98633       {
98634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98635       };
98636     }
98637   }
98638
98639   jresult = (void *)result;
98640   return jresult;
98641 }
98642
98643
98644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98645   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98646
98647   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98648   {
98649     try {
98650       delete arg1;
98651     } catch (std::out_of_range& e) {
98652       {
98653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98654       };
98655     } catch (std::exception& e) {
98656       {
98657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98658       };
98659     } catch (Dali::DaliException e) {
98660       {
98661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98662       };
98663     } catch (...) {
98664       {
98665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98666       };
98667     }
98668   }
98669
98670 }
98671
98672
98673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98674   unsigned int jresult ;
98675   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98676   bool result;
98677
98678   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98679   {
98680     try {
98681       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98682     } catch (std::out_of_range& e) {
98683       {
98684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98685       };
98686     } catch (std::exception& e) {
98687       {
98688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98689       };
98690     } catch (Dali::DaliException e) {
98691       {
98692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98693       };
98694     } catch (...) {
98695       {
98696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98697       };
98698     }
98699   }
98700
98701   jresult = result;
98702   return jresult;
98703 }
98704
98705
98706 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98707   unsigned long jresult ;
98708   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98709   std::size_t result;
98710
98711   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98712   {
98713     try {
98714       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98715     } catch (std::out_of_range& e) {
98716       {
98717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98718       };
98719     } catch (std::exception& e) {
98720       {
98721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98722       };
98723     } catch (Dali::DaliException e) {
98724       {
98725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98726       };
98727     } catch (...) {
98728       {
98729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98730       };
98731     }
98732   }
98733
98734   jresult = (unsigned long)result;
98735   return jresult;
98736 }
98737
98738
98739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98740   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98741   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98742
98743   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98744   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98745   {
98746     try {
98747       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98748     } catch (std::out_of_range& e) {
98749       {
98750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98751       };
98752     } catch (std::exception& e) {
98753       {
98754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98755       };
98756     } catch (Dali::DaliException e) {
98757       {
98758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98759       };
98760     } catch (...) {
98761       {
98762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98763       };
98764     }
98765   }
98766
98767 }
98768
98769
98770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98771   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98772   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98773
98774   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98775   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98776   {
98777     try {
98778       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98779     } catch (std::out_of_range& e) {
98780       {
98781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98782       };
98783     } catch (std::exception& e) {
98784       {
98785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98786       };
98787     } catch (Dali::DaliException e) {
98788       {
98789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98790       };
98791     } catch (...) {
98792       {
98793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98794       };
98795     }
98796   }
98797
98798 }
98799
98800
98801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98802   unsigned int jresult ;
98803   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98804   Dali::Toolkit::Slider arg2 ;
98805   int arg3 ;
98806   Dali::Toolkit::Slider *argp2 ;
98807   bool result;
98808
98809   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98810   argp2 = (Dali::Toolkit::Slider *)jarg2;
98811   if (!argp2) {
98812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98813     return 0;
98814   }
98815   arg2 = *argp2;
98816   arg3 = (int)jarg3;
98817   {
98818     try {
98819       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98820     } catch (std::out_of_range& e) {
98821       {
98822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98823       };
98824     } catch (std::exception& e) {
98825       {
98826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98827       };
98828     } catch (Dali::DaliException e) {
98829       {
98830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98831       };
98832     } catch (...) {
98833       {
98834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98835       };
98836     }
98837   }
98838
98839   jresult = result;
98840   return jresult;
98841 }
98842
98843
98844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98845   void * jresult ;
98846   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98847
98848   {
98849     try {
98850       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98851     } catch (std::out_of_range& e) {
98852       {
98853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98854       };
98855     } catch (std::exception& e) {
98856       {
98857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98858       };
98859     } catch (Dali::DaliException e) {
98860       {
98861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98862       };
98863     } catch (...) {
98864       {
98865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98866       };
98867     }
98868   }
98869
98870   jresult = (void *)result;
98871   return jresult;
98872 }
98873
98874
98875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98876   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98877
98878   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98879   {
98880     try {
98881       delete arg1;
98882     } catch (std::out_of_range& e) {
98883       {
98884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98885       };
98886     } catch (std::exception& e) {
98887       {
98888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98889       };
98890     } catch (Dali::DaliException e) {
98891       {
98892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98893       };
98894     } catch (...) {
98895       {
98896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98897       };
98898     }
98899   }
98900
98901 }
98902
98903
98904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98905   void * jresult ;
98906   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98907
98908   {
98909     try {
98910       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98911     } catch (std::out_of_range& e) {
98912       {
98913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98914       };
98915     } catch (std::exception& e) {
98916       {
98917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98918       };
98919     } catch (Dali::DaliException e) {
98920       {
98921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98922       };
98923     } catch (...) {
98924       {
98925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98926       };
98927     }
98928   }
98929
98930   jresult = (void *)result;
98931   return jresult;
98932 }
98933
98934
98935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98936   void * jresult ;
98937   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98938   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98939
98940   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98941   {
98942     try {
98943       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98944     } catch (std::out_of_range& e) {
98945       {
98946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98947       };
98948     } catch (std::exception& e) {
98949       {
98950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98951       };
98952     } catch (Dali::DaliException e) {
98953       {
98954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98955       };
98956     } catch (...) {
98957       {
98958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98959       };
98960     }
98961   }
98962
98963   jresult = (void *)result;
98964   return jresult;
98965 }
98966
98967
98968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98969   void * jresult ;
98970   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98971   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98972
98973   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98974   if (!arg1) {
98975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98976     return 0;
98977   }
98978   {
98979     try {
98980       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98981     } catch (std::out_of_range& e) {
98982       {
98983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98984       };
98985     } catch (std::exception& e) {
98986       {
98987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98988       };
98989     } catch (Dali::DaliException e) {
98990       {
98991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98992       };
98993     } catch (...) {
98994       {
98995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98996       };
98997     }
98998   }
98999
99000   jresult = (void *)result;
99001   return jresult;
99002 }
99003
99004
99005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99006   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99007
99008   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99009   {
99010     try {
99011       delete arg1;
99012     } catch (std::out_of_range& e) {
99013       {
99014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99015       };
99016     } catch (std::exception& e) {
99017       {
99018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99019       };
99020     } catch (Dali::DaliException e) {
99021       {
99022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99023       };
99024     } catch (...) {
99025       {
99026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99027       };
99028     }
99029   }
99030
99031 }
99032
99033
99034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99035   void * jresult ;
99036   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99037   Dali::Toolkit::Ruler *result = 0 ;
99038
99039   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99040   {
99041     try {
99042       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99043     } catch (std::out_of_range& e) {
99044       {
99045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99046       };
99047     } catch (std::exception& e) {
99048       {
99049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99050       };
99051     } catch (Dali::DaliException e) {
99052       {
99053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99054       };
99055     } catch (...) {
99056       {
99057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99058       };
99059     }
99060   }
99061
99062   jresult = (void *)result;
99063   return jresult;
99064 }
99065
99066
99067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99068   void * jresult ;
99069   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99070   Dali::Toolkit::Ruler *result = 0 ;
99071
99072   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99073   {
99074     try {
99075       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99076     } catch (std::out_of_range& e) {
99077       {
99078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99079       };
99080     } catch (std::exception& e) {
99081       {
99082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99083       };
99084     } catch (Dali::DaliException e) {
99085       {
99086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99087       };
99088     } catch (...) {
99089       {
99090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99091       };
99092     }
99093   }
99094
99095   jresult = (void *)result;
99096   return jresult;
99097 }
99098
99099
99100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99101   void * jresult ;
99102   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99103   Dali::Toolkit::Ruler *result = 0 ;
99104
99105   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99106   {
99107     try {
99108       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99109     } catch (std::out_of_range& e) {
99110       {
99111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99112       };
99113     } catch (std::exception& e) {
99114       {
99115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99116       };
99117     } catch (Dali::DaliException e) {
99118       {
99119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99120       };
99121     } catch (...) {
99122       {
99123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99124       };
99125     }
99126   }
99127
99128   jresult = (void *)result;
99129   return jresult;
99130 }
99131
99132
99133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99134   void * jresult ;
99135   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99136   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99137   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99138
99139   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99140   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99141   if (!arg2) {
99142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99143     return 0;
99144   }
99145   {
99146     try {
99147       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99148     } catch (std::out_of_range& e) {
99149       {
99150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99151       };
99152     } catch (std::exception& e) {
99153       {
99154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99155       };
99156     } catch (Dali::DaliException e) {
99157       {
99158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99159       };
99160     } catch (...) {
99161       {
99162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99163       };
99164     }
99165   }
99166
99167   jresult = (void *)result;
99168   return jresult;
99169 }
99170
99171
99172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99173   void * jresult ;
99174   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99175   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99176   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99177
99178   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99179   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99180   {
99181     try {
99182       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99183     } catch (std::out_of_range& e) {
99184       {
99185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99186       };
99187     } catch (std::exception& e) {
99188       {
99189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99190       };
99191     } catch (Dali::DaliException e) {
99192       {
99193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99194       };
99195     } catch (...) {
99196       {
99197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99198       };
99199     }
99200   }
99201
99202   jresult = (void *)result;
99203   return jresult;
99204 }
99205
99206
99207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99208   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99209
99210   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99211   {
99212     try {
99213       (arg1)->Reset();
99214     } catch (std::out_of_range& e) {
99215       {
99216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99217       };
99218     } catch (std::exception& e) {
99219       {
99220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99221       };
99222     } catch (Dali::DaliException e) {
99223       {
99224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99225       };
99226     } catch (...) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99229       };
99230     }
99231   }
99232
99233 }
99234
99235
99236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99237   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99238   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99239
99240   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99241   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99242   {
99243     try {
99244       (arg1)->Reset(arg2);
99245     } catch (std::out_of_range& e) {
99246       {
99247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99248       };
99249     } catch (std::exception& e) {
99250       {
99251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99252       };
99253     } catch (Dali::DaliException e) {
99254       {
99255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99256       };
99257     } catch (...) {
99258       {
99259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99260       };
99261     }
99262   }
99263
99264 }
99265
99266
99267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99268   void * jresult ;
99269   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99270   Dali::Toolkit::Ruler *result = 0 ;
99271
99272   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99273   {
99274     try {
99275       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99276     } catch (std::out_of_range& e) {
99277       {
99278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99279       };
99280     } catch (std::exception& e) {
99281       {
99282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99283       };
99284     } catch (Dali::DaliException e) {
99285       {
99286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99287       };
99288     } catch (...) {
99289       {
99290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99291       };
99292     }
99293   }
99294
99295   jresult = (void *)result;
99296   return jresult;
99297 }
99298
99299
99300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99301   float jresult ;
99302   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99303   float arg2 ;
99304   float arg3 ;
99305   float result;
99306
99307   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99308   arg2 = (float)jarg2;
99309   arg3 = (float)jarg3;
99310   {
99311     try {
99312       result = (float)(*arg1)->Snap(arg2,arg3);
99313     } catch (std::out_of_range& e) {
99314       {
99315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99316       };
99317     } catch (std::exception& e) {
99318       {
99319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99320       };
99321     } catch (Dali::DaliException e) {
99322       {
99323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99324       };
99325     } catch (...) {
99326       {
99327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99328       };
99329     }
99330   }
99331
99332   jresult = result;
99333   return jresult;
99334 }
99335
99336
99337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99338   float jresult ;
99339   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99340   float arg2 ;
99341   float result;
99342
99343   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99344   arg2 = (float)jarg2;
99345   {
99346     try {
99347       result = (float)(*arg1)->Snap(arg2);
99348     } catch (std::out_of_range& e) {
99349       {
99350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99351       };
99352     } catch (std::exception& e) {
99353       {
99354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99355       };
99356     } catch (Dali::DaliException e) {
99357       {
99358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99359       };
99360     } catch (...) {
99361       {
99362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99363       };
99364     }
99365   }
99366
99367   jresult = result;
99368   return jresult;
99369 }
99370
99371
99372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99373   float jresult ;
99374   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99375   unsigned int arg2 ;
99376   unsigned int *arg3 = 0 ;
99377   bool arg4 ;
99378   float result;
99379
99380   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99381   arg2 = (unsigned int)jarg2;
99382   arg3 = (unsigned int *)jarg3;
99383   arg4 = jarg4 ? true : false;
99384   {
99385     try {
99386       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99387     } catch (std::out_of_range& e) {
99388       {
99389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99390       };
99391     } catch (std::exception& e) {
99392       {
99393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99394       };
99395     } catch (Dali::DaliException e) {
99396       {
99397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99398       };
99399     } catch (...) {
99400       {
99401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99402       };
99403     }
99404   }
99405
99406   jresult = result;
99407   return jresult;
99408 }
99409
99410
99411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99412   unsigned int jresult ;
99413   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99414   float arg2 ;
99415   bool arg3 ;
99416   unsigned int result;
99417
99418   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99419   arg2 = (float)jarg2;
99420   arg3 = jarg3 ? true : false;
99421   {
99422     try {
99423       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99424     } catch (std::out_of_range& e) {
99425       {
99426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99427       };
99428     } catch (std::exception& e) {
99429       {
99430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99431       };
99432     } catch (Dali::DaliException e) {
99433       {
99434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99435       };
99436     } catch (...) {
99437       {
99438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99439       };
99440     }
99441   }
99442
99443   jresult = result;
99444   return jresult;
99445 }
99446
99447
99448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99449   unsigned int jresult ;
99450   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99451   unsigned int result;
99452
99453   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99454   {
99455     try {
99456       result = (unsigned int)(*arg1)->GetTotalPages();
99457     } catch (std::out_of_range& e) {
99458       {
99459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99460       };
99461     } catch (std::exception& e) {
99462       {
99463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99464       };
99465     } catch (Dali::DaliException e) {
99466       {
99467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99468       };
99469     } catch (...) {
99470       {
99471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99472       };
99473     }
99474   }
99475
99476   jresult = result;
99477   return jresult;
99478 }
99479
99480
99481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99482   int jresult ;
99483   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99484   Dali::Toolkit::Ruler::RulerType result;
99485
99486   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99487   {
99488     try {
99489       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99490     } catch (std::out_of_range& e) {
99491       {
99492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99493       };
99494     } catch (std::exception& e) {
99495       {
99496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99497       };
99498     } catch (Dali::DaliException e) {
99499       {
99500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99501       };
99502     } catch (...) {
99503       {
99504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99505       };
99506     }
99507   }
99508
99509   jresult = (int)result;
99510   return jresult;
99511 }
99512
99513
99514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99515   unsigned int jresult ;
99516   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99517   bool result;
99518
99519   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99520   {
99521     try {
99522       result = (bool)(*arg1)->IsEnabled();
99523     } catch (std::out_of_range& e) {
99524       {
99525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99526       };
99527     } catch (std::exception& e) {
99528       {
99529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99530       };
99531     } catch (Dali::DaliException e) {
99532       {
99533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99534       };
99535     } catch (...) {
99536       {
99537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99538       };
99539     }
99540   }
99541
99542   jresult = result;
99543   return jresult;
99544 }
99545
99546
99547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99548   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99549
99550   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99551   {
99552     try {
99553       (*arg1)->Enable();
99554     } catch (std::out_of_range& e) {
99555       {
99556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99557       };
99558     } catch (std::exception& e) {
99559       {
99560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99561       };
99562     } catch (Dali::DaliException e) {
99563       {
99564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99565       };
99566     } catch (...) {
99567       {
99568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99569       };
99570     }
99571   }
99572
99573 }
99574
99575
99576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99577   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99578
99579   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99580   {
99581     try {
99582       (*arg1)->Disable();
99583     } catch (std::out_of_range& e) {
99584       {
99585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99586       };
99587     } catch (std::exception& e) {
99588       {
99589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99590       };
99591     } catch (Dali::DaliException e) {
99592       {
99593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99594       };
99595     } catch (...) {
99596       {
99597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99598       };
99599     }
99600   }
99601
99602 }
99603
99604
99605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99606   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99607   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99608   Dali::Toolkit::RulerDomain *argp2 ;
99609
99610   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99611   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99612   if (!argp2) {
99613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99614     return ;
99615   }
99616   arg2 = *argp2;
99617   {
99618     try {
99619       (*arg1)->SetDomain(arg2);
99620     } catch (std::out_of_range& e) {
99621       {
99622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99623       };
99624     } catch (std::exception& e) {
99625       {
99626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99627       };
99628     } catch (Dali::DaliException e) {
99629       {
99630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99631       };
99632     } catch (...) {
99633       {
99634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99635       };
99636     }
99637   }
99638
99639 }
99640
99641
99642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99643   void * jresult ;
99644   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99645   Dali::Toolkit::RulerDomain *result = 0 ;
99646
99647   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99648   {
99649     try {
99650       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99651     } catch (std::out_of_range& e) {
99652       {
99653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99654       };
99655     } catch (std::exception& e) {
99656       {
99657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99658       };
99659     } catch (Dali::DaliException e) {
99660       {
99661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99662       };
99663     } catch (...) {
99664       {
99665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99666       };
99667     }
99668   }
99669
99670   jresult = (void *)result;
99671   return jresult;
99672 }
99673
99674
99675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99676   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99677
99678   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99679   {
99680     try {
99681       (*arg1)->DisableDomain();
99682     } catch (std::out_of_range& e) {
99683       {
99684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99685       };
99686     } catch (std::exception& e) {
99687       {
99688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99689       };
99690     } catch (Dali::DaliException e) {
99691       {
99692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99693       };
99694     } catch (...) {
99695       {
99696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99697       };
99698     }
99699   }
99700
99701 }
99702
99703
99704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99705   float jresult ;
99706   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99707   float arg2 ;
99708   float arg3 ;
99709   float arg4 ;
99710   float result;
99711
99712   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99713   arg2 = (float)jarg2;
99714   arg3 = (float)jarg3;
99715   arg4 = (float)jarg4;
99716   {
99717     try {
99718       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99719     } catch (std::out_of_range& e) {
99720       {
99721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99722       };
99723     } catch (std::exception& e) {
99724       {
99725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99726       };
99727     } catch (Dali::DaliException e) {
99728       {
99729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99730       };
99731     } catch (...) {
99732       {
99733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99734       };
99735     }
99736   }
99737
99738   jresult = result;
99739   return jresult;
99740 }
99741
99742
99743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99744   float jresult ;
99745   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99746   float arg2 ;
99747   float arg3 ;
99748   float result;
99749
99750   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99751   arg2 = (float)jarg2;
99752   arg3 = (float)jarg3;
99753   {
99754     try {
99755       result = (float)(*arg1)->Clamp(arg2,arg3);
99756     } catch (std::out_of_range& e) {
99757       {
99758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99759       };
99760     } catch (std::exception& e) {
99761       {
99762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99763       };
99764     } catch (Dali::DaliException e) {
99765       {
99766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99767       };
99768     } catch (...) {
99769       {
99770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99771       };
99772     }
99773   }
99774
99775   jresult = result;
99776   return jresult;
99777 }
99778
99779
99780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99781   float jresult ;
99782   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99783   float arg2 ;
99784   float result;
99785
99786   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99787   arg2 = (float)jarg2;
99788   {
99789     try {
99790       result = (float)(*arg1)->Clamp(arg2);
99791     } catch (std::out_of_range& e) {
99792       {
99793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99794       };
99795     } catch (std::exception& e) {
99796       {
99797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99798       };
99799     } catch (Dali::DaliException e) {
99800       {
99801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99802       };
99803     } catch (...) {
99804       {
99805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99806       };
99807     }
99808   }
99809
99810   jresult = result;
99811   return jresult;
99812 }
99813
99814
99815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99816   float jresult ;
99817   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99818   float arg2 ;
99819   float arg3 ;
99820   float arg4 ;
99821   Dali::Toolkit::ClampState *arg5 = 0 ;
99822   float result;
99823
99824   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99825   arg2 = (float)jarg2;
99826   arg3 = (float)jarg3;
99827   arg4 = (float)jarg4;
99828   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99829   if (!arg5) {
99830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99831     return 0;
99832   }
99833   {
99834     try {
99835       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99836     } catch (std::out_of_range& e) {
99837       {
99838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99839       };
99840     } catch (std::exception& e) {
99841       {
99842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99843       };
99844     } catch (Dali::DaliException e) {
99845       {
99846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99847       };
99848     } catch (...) {
99849       {
99850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99851       };
99852     }
99853   }
99854
99855   jresult = result;
99856   return jresult;
99857 }
99858
99859
99860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99861   float jresult ;
99862   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99863   float arg2 ;
99864   float arg3 ;
99865   float arg4 ;
99866   float arg5 ;
99867   float result;
99868
99869   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99870   arg2 = (float)jarg2;
99871   arg3 = (float)jarg3;
99872   arg4 = (float)jarg4;
99873   arg5 = (float)jarg5;
99874   {
99875     try {
99876       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99877     } catch (std::out_of_range& e) {
99878       {
99879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99880       };
99881     } catch (std::exception& e) {
99882       {
99883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99884       };
99885     } catch (Dali::DaliException e) {
99886       {
99887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99888       };
99889     } catch (...) {
99890       {
99891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99892       };
99893     }
99894   }
99895
99896   jresult = result;
99897   return jresult;
99898 }
99899
99900
99901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99902   float jresult ;
99903   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99904   float arg2 ;
99905   float arg3 ;
99906   float arg4 ;
99907   float result;
99908
99909   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99910   arg2 = (float)jarg2;
99911   arg3 = (float)jarg3;
99912   arg4 = (float)jarg4;
99913   {
99914     try {
99915       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99916     } catch (std::out_of_range& e) {
99917       {
99918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99919       };
99920     } catch (std::exception& e) {
99921       {
99922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99923       };
99924     } catch (Dali::DaliException e) {
99925       {
99926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99927       };
99928     } catch (...) {
99929       {
99930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99931       };
99932     }
99933   }
99934
99935   jresult = result;
99936   return jresult;
99937 }
99938
99939
99940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99941   float jresult ;
99942   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99943   float arg2 ;
99944   float arg3 ;
99945   float result;
99946
99947   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99948   arg2 = (float)jarg2;
99949   arg3 = (float)jarg3;
99950   {
99951     try {
99952       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99953     } catch (std::out_of_range& e) {
99954       {
99955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99956       };
99957     } catch (std::exception& e) {
99958       {
99959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99960       };
99961     } catch (Dali::DaliException e) {
99962       {
99963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99964       };
99965     } catch (...) {
99966       {
99967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99968       };
99969     }
99970   }
99971
99972   jresult = result;
99973   return jresult;
99974 }
99975
99976
99977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99978   float jresult ;
99979   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99980   float arg2 ;
99981   float result;
99982
99983   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99984   arg2 = (float)jarg2;
99985   {
99986     try {
99987       result = (float)(*arg1)->SnapAndClamp(arg2);
99988     } catch (std::out_of_range& e) {
99989       {
99990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99991       };
99992     } catch (std::exception& e) {
99993       {
99994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99995       };
99996     } catch (Dali::DaliException e) {
99997       {
99998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99999       };
100000     } catch (...) {
100001       {
100002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100003       };
100004     }
100005   }
100006
100007   jresult = result;
100008   return jresult;
100009 }
100010
100011
100012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100013   float jresult ;
100014   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100015   float arg2 ;
100016   float arg3 ;
100017   float arg4 ;
100018   float arg5 ;
100019   Dali::Toolkit::ClampState *arg6 = 0 ;
100020   float result;
100021
100022   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100023   arg2 = (float)jarg2;
100024   arg3 = (float)jarg3;
100025   arg4 = (float)jarg4;
100026   arg5 = (float)jarg5;
100027   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100028   if (!arg6) {
100029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100030     return 0;
100031   }
100032   {
100033     try {
100034       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100035     } catch (std::out_of_range& e) {
100036       {
100037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100038       };
100039     } catch (std::exception& e) {
100040       {
100041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100042       };
100043     } catch (Dali::DaliException e) {
100044       {
100045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100046       };
100047     } catch (...) {
100048       {
100049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100050       };
100051     }
100052   }
100053
100054   jresult = result;
100055   return jresult;
100056 }
100057
100058
100059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100060   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100061
100062   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100063   {
100064     try {
100065       (*arg1)->Reference();
100066     } catch (std::out_of_range& e) {
100067       {
100068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100069       };
100070     } catch (std::exception& e) {
100071       {
100072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100073       };
100074     } catch (Dali::DaliException e) {
100075       {
100076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100077       };
100078     } catch (...) {
100079       {
100080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100081       };
100082     }
100083   }
100084
100085 }
100086
100087
100088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100089   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100090
100091   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100092   {
100093     try {
100094       (*arg1)->Unreference();
100095     } catch (std::out_of_range& e) {
100096       {
100097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100098       };
100099     } catch (std::exception& e) {
100100       {
100101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100102       };
100103     } catch (Dali::DaliException e) {
100104       {
100105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100106       };
100107     } catch (...) {
100108       {
100109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100110       };
100111     }
100112   }
100113
100114 }
100115
100116
100117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100118   int jresult ;
100119   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100120   int result;
100121
100122   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100123   {
100124     try {
100125       result = (int)(*arg1)->ReferenceCount();
100126     } catch (std::out_of_range& e) {
100127       {
100128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100129       };
100130     } catch (std::exception& e) {
100131       {
100132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100133       };
100134     } catch (Dali::DaliException e) {
100135       {
100136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100137       };
100138     } catch (...) {
100139       {
100140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100141       };
100142     }
100143   }
100144
100145   jresult = result;
100146   return jresult;
100147 }
100148
100149
100150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100151   unsigned int jresult ;
100152   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100153   bool result;
100154
100155   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100156   {
100157     try {
100158       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100159     } catch (std::out_of_range& e) {
100160       {
100161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100162       };
100163     } catch (std::exception& e) {
100164       {
100165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100166       };
100167     } catch (Dali::DaliException e) {
100168       {
100169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100170       };
100171     } catch (...) {
100172       {
100173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100174       };
100175     }
100176   }
100177
100178   jresult = result;
100179   return jresult;
100180 }
100181
100182
100183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100184   unsigned long jresult ;
100185   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100186   std::size_t result;
100187
100188   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100189   {
100190     try {
100191       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100192     } catch (std::out_of_range& e) {
100193       {
100194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100195       };
100196     } catch (std::exception& e) {
100197       {
100198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100199       };
100200     } catch (Dali::DaliException e) {
100201       {
100202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100203       };
100204     } catch (...) {
100205       {
100206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100207       };
100208     }
100209   }
100210
100211   jresult = (unsigned long)result;
100212   return jresult;
100213 }
100214
100215
100216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100217   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100218   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100219
100220   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100221   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100222   {
100223     try {
100224       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100225     } catch (std::out_of_range& e) {
100226       {
100227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100228       };
100229     } catch (std::exception& e) {
100230       {
100231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100232       };
100233     } catch (Dali::DaliException e) {
100234       {
100235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100236       };
100237     } catch (...) {
100238       {
100239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100240       };
100241     }
100242   }
100243
100244 }
100245
100246
100247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100248   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100249   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100250
100251   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100252   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100253   {
100254     try {
100255       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100256     } catch (std::out_of_range& e) {
100257       {
100258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100259       };
100260     } catch (std::exception& e) {
100261       {
100262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100263       };
100264     } catch (Dali::DaliException e) {
100265       {
100266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100267       };
100268     } catch (...) {
100269       {
100270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100271       };
100272     }
100273   }
100274
100275 }
100276
100277
100278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100279   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100280   Dali::Toolkit::Control arg2 ;
100281   Dali::Toolkit::Control *argp2 ;
100282
100283   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100284   argp2 = (Dali::Toolkit::Control *)jarg2;
100285   if (!argp2) {
100286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100287     return ;
100288   }
100289   arg2 = *argp2;
100290   {
100291     try {
100292       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100293     } catch (std::out_of_range& e) {
100294       {
100295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100296       };
100297     } catch (std::exception& e) {
100298       {
100299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100300       };
100301     } catch (Dali::DaliException e) {
100302       {
100303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100304       };
100305     } catch (...) {
100306       {
100307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100308       };
100309     }
100310   }
100311
100312 }
100313
100314
100315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100316   void * jresult ;
100317   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100318
100319   {
100320     try {
100321       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100322     } catch (std::out_of_range& e) {
100323       {
100324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100325       };
100326     } catch (std::exception& e) {
100327       {
100328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100329       };
100330     } catch (Dali::DaliException e) {
100331       {
100332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100333       };
100334     } catch (...) {
100335       {
100336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100337       };
100338     }
100339   }
100340
100341   jresult = (void *)result;
100342   return jresult;
100343 }
100344
100345
100346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100347   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100348
100349   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100350   {
100351     try {
100352       delete arg1;
100353     } catch (std::out_of_range& e) {
100354       {
100355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100356       };
100357     } catch (std::exception& e) {
100358       {
100359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100360       };
100361     } catch (Dali::DaliException e) {
100362       {
100363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100364       };
100365     } catch (...) {
100366       {
100367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100368       };
100369     }
100370   }
100371
100372 }
100373
100374 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100375   Dali::RefObject *result = NULL;
100376
100377   if (arg1)
100378   {
100379     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100380   }
100381   return result;
100382 }
100383
100384 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100385     return (Dali::RefObject *)jarg1;
100386 }
100387
100388 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100389     return (Dali::SignalObserver *)jarg1;
100390 }
100391
100392 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100393     return (Dali::ConnectionTrackerInterface *)jarg1;
100394 }
100395
100396 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100397     return (Dali::BaseHandle *)jarg1;
100398 }
100399
100400 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100401     return (Dali::BaseHandle *)jarg1;
100402 }
100403
100404 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100405     return (Dali::BaseHandle *)jarg1;
100406 }
100407
100408 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100409     return (Dali::BaseHandle *)jarg1;
100410 }
100411
100412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100413     return (Dali::BaseHandle *)jarg1;
100414 }
100415
100416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100417     return (Dali::BaseHandle *)jarg1;
100418 }
100419
100420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100421     return (Dali::BaseHandle *)jarg1;
100422 }
100423
100424 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100425     return (Dali::BaseHandle *)jarg1;
100426 }
100427
100428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100429     return (Dali::BaseHandle *)jarg1;
100430 }
100431
100432 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100433     return (Dali::BaseHandle *)jarg1;
100434 }
100435
100436 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100437     return (Dali::BaseHandle *)jarg1;
100438 }
100439
100440 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100441     return (Dali::BaseHandle *)jarg1;
100442 }
100443
100444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100445     return (Dali::BaseHandle *)jarg1;
100446 }
100447
100448 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100449     return (Dali::Handle *)jarg1;
100450 }
100451
100452 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100453     return (Dali::Handle *)jarg1;
100454 }
100455
100456 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100457     return (Dali::BaseHandle *)jarg1;
100458 }
100459
100460 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100461     return (Dali::BaseHandle *)jarg1;
100462 }
100463
100464 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100465     return (Dali::Handle *)jarg1;
100466 }
100467
100468 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100469     return (Dali::BaseHandle *)jarg1;
100470 }
100471
100472 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100473     return (Dali::Handle *)jarg1;
100474 }
100475
100476 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100477     return (Dali::GestureDetector *)jarg1;
100478 }
100479
100480 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100481     return (Dali::Gesture *)jarg1;
100482 }
100483
100484 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100485     return (Dali::Handle *)jarg1;
100486 }
100487
100488 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100489     return (Dali::Actor *)jarg1;
100490 }
100491
100492 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100493     return (Dali::BaseHandle *)jarg1;
100494 }
100495
100496 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100497     return (Dali::RefObject *)jarg1;
100498 }
100499
100500 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100501     return (Dali::Actor *)jarg1;
100502 }
100503
100504 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100505     return (Dali::GestureDetector *)jarg1;
100506 }
100507
100508 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100509     return (Dali::Gesture *)jarg1;
100510 }
100511
100512 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100513     return (Dali::GestureDetector *)jarg1;
100514 }
100515
100516 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100517     return (Dali::Gesture *)jarg1;
100518 }
100519
100520 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100521     return (Dali::GestureDetector *)jarg1;
100522 }
100523
100524 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100525     return (Dali::Gesture *)jarg1;
100526 }
100527
100528 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100529     return (Dali::BaseHandle *)jarg1;
100530 }
100531
100532 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100533     return (Dali::Handle *)jarg1;
100534 }
100535
100536 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100537     return (Dali::Handle *)jarg1;
100538 }
100539
100540 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100541     return (Dali::Handle *)jarg1;
100542 }
100543
100544 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100545     return (Dali::Image *)jarg1;
100546 }
100547
100548 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100549     return (Dali::Image *)jarg1;
100550 }
100551
100552 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100553     return (Dali::Image *)jarg1;
100554 }
100555
100556 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100557     return (Dali::RefObject *)jarg1;
100558 }
100559
100560 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100561     return (Dali::Image *)jarg1;
100562 }
100563
100564 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100565     return (Dali::Image *)jarg1;
100566 }
100567
100568 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100569     return (Dali::ResourceImage *)jarg1;
100570 }
100571
100572 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100573     return (Dali::Actor *)jarg1;
100574 }
100575
100576 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100577     return (Dali::BaseHandle *)jarg1;
100578 }
100579
100580 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100581     return (Dali::BaseHandle *)jarg1;
100582 }
100583
100584 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100585     return (Dali::BaseHandle *)jarg1;
100586 }
100587
100588 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100589     return (Dali::CustomActorImpl *)jarg1;
100590 }
100591
100592 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100593     return (Dali::CustomActor *)jarg1;
100594 }
100595
100596 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100597     return (Dali::BaseHandle *)jarg1;
100598 }
100599
100600 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100601     return (Dali::Toolkit::Control *)jarg1;
100602 }
100603
100604 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100605     return (Dali::Toolkit::Control *)jarg1;
100606 }
100607
100608 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100609     return (Dali::Toolkit::Button *)jarg1;
100610 }
100611
100612 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100613     return (Dali::Toolkit::Button *)jarg1;
100614 }
100615
100616 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100617     return (Dali::Toolkit::Button *)jarg1;
100618 }
100619
100620 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100621     return (Dali::Toolkit::Control *)jarg1;
100622 }
100623
100624 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100625     return (Dali::Toolkit::Control *)jarg1;
100626 }
100627
100628 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100629     return (Dali::Toolkit::Control *)jarg1;
100630 }
100631
100632 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100633     return (Dali::Toolkit::Control *)jarg1;
100634 }
100635
100636 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100637     return (Dali::Toolkit::Control *)jarg1;
100638 }
100639
100640 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100641     return (Dali::RefObject *)jarg1;
100642 }
100643
100644 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100645     return (Dali::Toolkit::Scrollable *)jarg1;
100646 }
100647
100648 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100649     return (Dali::BaseHandle *)jarg1;
100650 }
100651
100652 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100653     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100654 }
100655
100656 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100657     return (Dali::RefObject *)jarg1;
100658 }
100659
100660 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100661     return (Dali::Toolkit::Ruler *)jarg1;
100662 }
100663
100664 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100665     return (Dali::Toolkit::Ruler *)jarg1;
100666 }
100667
100668 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100669     return (Dali::Toolkit::Scrollable *)jarg1;
100670 }
100671
100672 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100673     return (Dali::Toolkit::Control *)jarg1;
100674 }
100675
100676
100677 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100678     return (Dali::Toolkit::Control *)jarg1;
100679 }
100680
100681 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100682     return (Dali::BaseHandle *)jarg1;
100683 }
100684
100685 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100686     return (Dali::BaseHandle *)jarg1;
100687 }
100688
100689 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100690     return (Dali::Toolkit::Control *)jarg1;
100691 }
100692
100693 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100694     return (Dali::Toolkit::Control *)jarg1;
100695 }
100696
100697 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100698     return (Dali::Toolkit::Control *)jarg1;
100699 }
100700
100701 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100702     return (Dali::Toolkit::Control *)jarg1;
100703 }
100704
100705 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100706     return (Dali::Toolkit::Control *)jarg1;
100707 }
100708
100709 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100710     return (Dali::Toolkit::Control *)jarg1;
100711 }
100712
100713 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100714     return (Dali::Toolkit::PageTurnView *)jarg1;
100715 }
100716
100717 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100718     return (Dali::Toolkit::PageTurnView *)jarg1;
100719 }
100720
100721 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100722     return (Dali::Toolkit::Button *)jarg1;
100723 }
100724
100725 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100726     return (Dali::BaseHandle *)jarg1;
100727 }
100728
100729 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100730     return (Dali::BaseHandle *)jarg1;
100731 }
100732
100733 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100734     return (Dali::BaseHandle *)jarg1;
100735 }
100736
100737 /*
100738  * Widget binding
100739  */
100740 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100741     return (Dali::BaseHandle *)jarg1;
100742 }
100743
100744 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100745     return (Dali::BaseObject *)jarg1;
100746 }
100747
100748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100749   void * jresult ;
100750   Dali::Widget result;
100751
100752   {
100753     try {
100754       result = Dali::Widget::New();
100755     } catch (std::out_of_range& e) {
100756       {
100757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100758       };
100759     } catch (std::exception& e) {
100760       {
100761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100762       };
100763     } catch (...) {
100764       {
100765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100766       };
100767     }
100768   }
100769   jresult = new Dali::Widget((const Dali::Widget &)result);
100770   return jresult;
100771 }
100772
100773
100774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100775   void * jresult ;
100776   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100777   Dali::Widget result;
100778
100779   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100780
100781   if (!arg1) {
100782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100783     return 0;
100784   }
100785   {
100786     try {
100787       jresult = new Dali::Widget(arg1);
100788     } catch (std::out_of_range& e) {
100789       {
100790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100791       };
100792     } catch (std::exception& e) {
100793       {
100794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100795       };
100796     } catch (...) {
100797       {
100798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100799       };
100800     }
100801   }
100802   return jresult;
100803 }
100804
100805
100806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100807   void * jresult ;
100808   Dali::Widget *result = 0 ;
100809
100810   {
100811     try {
100812       result = (Dali::Widget *)new Dali::Widget();
100813     } catch (std::out_of_range& e) {
100814       {
100815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100816       };
100817     } catch (std::exception& e) {
100818       {
100819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100820       };
100821     } catch (...) {
100822       {
100823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100824       };
100825     }
100826   }
100827   jresult = (void *)result;
100828   return jresult;
100829 }
100830
100831
100832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100833   void * jresult ;
100834   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100835   Dali::Widget *arg2 = 0 ;
100836   Dali::Widget *result = 0 ;
100837
100838   arg1 = (Dali::Widget *)jarg1;
100839   arg2 = (Dali::Widget *)jarg2;
100840   if (!arg2) {
100841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100842     return 0;
100843   }
100844   {
100845     try {
100846       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100847     } catch (std::out_of_range& e) {
100848       {
100849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100850       };
100851     } catch (std::exception& e) {
100852       {
100853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100854       };
100855     } catch (...) {
100856       {
100857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100858       };
100859     }
100860   }
100861   jresult = (void *)result;
100862   return jresult;
100863 }
100864
100865
100866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100867   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100868
100869   arg1 = (Dali::Widget *)jarg1;
100870   {
100871     try {
100872       delete arg1;
100873     } catch (std::out_of_range& e) {
100874       {
100875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100876       };
100877     } catch (std::exception& e) {
100878       {
100879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100880       };
100881     } catch (...) {
100882       {
100883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100884       };
100885     }
100886   }
100887 }
100888
100889
100890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100891   void * jresult ;
100892   SwigDirector_WidgetImpl* result;
100893   {
100894     try {
100895       result = new SwigDirector_WidgetImpl();
100896     } catch (std::out_of_range& e) {
100897       {
100898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100899       };
100900     } catch (std::exception& e) {
100901       {
100902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100903       };
100904     } catch (...) {
100905       {
100906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100907       };
100908     }
100909   }
100910   jresult = result;
100911   return jresult;
100912 }
100913
100914
100915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100916   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100917   std::string *arg2 = 0 ;
100918   Dali::Window arg3 ;
100919   Dali::Window *argp3 ;
100920
100921   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100922   if (!jarg2) {
100923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100924     return ;
100925   }
100926   std::string arg2_str(jarg2);
100927   arg2 = &arg2_str;
100928   argp3 = (Dali::Window *)jarg3;
100929   if (!argp3) {
100930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100931     return ;
100932   }
100933   arg3 = *argp3;
100934   {
100935     try {
100936       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100937     } catch (std::out_of_range& e) {
100938       {
100939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100940       };
100941     } catch (std::exception& e) {
100942       {
100943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100944       };
100945     } catch (...) {
100946       {
100947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100948       };
100949     }
100950   }
100951 }
100952
100953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100954   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100955   std::string *arg2 = 0 ;
100956   Dali::Window arg3 ;
100957   Dali::Window *argp3 ;
100958
100959   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100960   if (!jarg2) {
100961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100962     return ;
100963   }
100964   std::string arg2_str(jarg2);
100965   arg2 = &arg2_str;
100966   argp3 = (Dali::Window *)jarg3;
100967   if (!argp3) {
100968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100969     return ;
100970   }
100971   arg3 = *argp3;
100972   {
100973     try {
100974       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100975     } catch (std::out_of_range& e) {
100976       {
100977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100978       };
100979     } catch (std::exception& e) {
100980       {
100981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100982       };
100983     } catch (...) {
100984       {
100985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100986       };
100987     }
100988   }
100989 }
100990
100991
100992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100993   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100994   std::string *arg2 = 0 ;
100995   Dali::Widget::Termination arg3 ;
100996
100997   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100998   if (!jarg2) {
100999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101000     return ;
101001   }
101002   std::string arg2_str(jarg2);
101003   arg2 = &arg2_str;
101004   arg3 = (Dali::Widget::Termination)jarg3;
101005   {
101006     try {
101007       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101008     } catch (std::out_of_range& e) {
101009       {
101010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101011       };
101012     } catch (std::exception& e) {
101013       {
101014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101015       };
101016     } catch (...) {
101017       {
101018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101019       };
101020     }
101021   }
101022 }
101023
101024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101025   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101026   std::string *arg2 = 0 ;
101027   Dali::Widget::Termination arg3 ;
101028
101029   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101030   if (!jarg2) {
101031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101032     return ;
101033   }
101034   std::string arg2_str(jarg2);
101035   arg2 = &arg2_str;
101036   arg3 = (Dali::Widget::Termination)jarg3;
101037   {
101038     try {
101039       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101040     } catch (std::out_of_range& e) {
101041       {
101042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101043       };
101044     } catch (std::exception& e) {
101045       {
101046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101047       };
101048     } catch (...) {
101049       {
101050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101051       };
101052     }
101053   }
101054 }
101055
101056
101057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101058   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101059
101060   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101061   {
101062     try {
101063       (arg1)->OnPause();
101064     } catch (std::out_of_range& e) {
101065       {
101066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101067       };
101068     } catch (std::exception& e) {
101069       {
101070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101071       };
101072     } catch (...) {
101073       {
101074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101075       };
101076     }
101077   }
101078 }
101079
101080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101081   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101082
101083   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101084   {
101085     try {
101086       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101087     } catch (std::out_of_range& e) {
101088       {
101089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101090       };
101091     } catch (std::exception& e) {
101092       {
101093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101094       };
101095     } catch (...) {
101096       {
101097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101098       };
101099     }
101100   }
101101 }
101102
101103
101104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101105   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101106
101107   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101108   {
101109     try {
101110       (arg1)->OnResume();
101111     } catch (std::out_of_range& e) {
101112       {
101113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101114       };
101115     } catch (std::exception& e) {
101116       {
101117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101118       };
101119     } catch (...) {
101120       {
101121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101122       };
101123     }
101124   }
101125 }
101126
101127
101128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101129   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101130
101131   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101132   {
101133     try {
101134       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101135     } catch (std::out_of_range& e) {
101136       {
101137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101138       };
101139     } catch (std::exception& e) {
101140       {
101141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101142       };
101143     } catch (...) {
101144       {
101145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101146       };
101147     }
101148   }
101149 }
101150
101151
101152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101153   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101154   Dali::Window arg2 ;
101155   Dali::Window *argp2 ;
101156
101157   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101158   argp2 = (Dali::Window *)jarg2;
101159   if (!argp2) {
101160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101161     return ;
101162   }
101163   arg2 = *argp2;
101164   {
101165     try {
101166       (arg1)->OnResize(arg2);
101167     } catch (std::out_of_range& e) {
101168       {
101169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101170       };
101171     } catch (std::exception& e) {
101172       {
101173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101174       };
101175     } catch (...) {
101176       {
101177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101178       };
101179     }
101180   }
101181 }
101182
101183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101184   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101185   Dali::Window arg2 ;
101186   Dali::Window *argp2 ;
101187
101188   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101189   argp2 = (Dali::Window *)jarg2;
101190   if (!argp2) {
101191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101192     return ;
101193   }
101194   arg2 = *argp2;
101195   {
101196     try {
101197       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101198     } catch (std::out_of_range& e) {
101199       {
101200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101201       };
101202     } catch (std::exception& e) {
101203       {
101204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101205       };
101206     } catch (...) {
101207       {
101208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101209       };
101210     }
101211   }
101212 }
101213
101214
101215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101216   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101217   std::string *arg2 = 0 ;
101218   int arg3 ;
101219
101220   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101221   if (!jarg2) {
101222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101223     return ;
101224   }
101225   std::string arg2_str(jarg2);
101226   arg2 = &arg2_str;
101227   arg3 = (int)jarg3;
101228   {
101229     try {
101230       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101231     } catch (std::out_of_range& e) {
101232       {
101233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101234       };
101235     } catch (std::exception& e) {
101236       {
101237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101238       };
101239     } catch (...) {
101240       {
101241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101242       };
101243     }
101244   }
101245 }
101246
101247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101248   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101249   std::string *arg2 = 0 ;
101250   int arg3 ;
101251
101252   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101253   if (!jarg2) {
101254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101255     return ;
101256   }
101257   std::string arg2_str(jarg2);
101258   arg2 = &arg2_str;
101259   arg3 = (int)jarg3;
101260   {
101261     try {
101262       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101263     } catch (std::out_of_range& e) {
101264       {
101265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101266       };
101267     } catch (std::exception& e) {
101268       {
101269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101270       };
101271     } catch (...) {
101272       {
101273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101274       };
101275     }
101276   }
101277 }
101278
101279
101280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101281   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101282   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101283   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101284
101285   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101286   arg2 = (Dali::SlotObserver *)jarg2;
101287   arg3 = (Dali::CallbackBase *)jarg3;
101288   {
101289     try {
101290       (arg1)->SignalConnected(arg2,arg3);
101291     } catch (std::out_of_range& e) {
101292       {
101293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101294       };
101295     } catch (std::exception& e) {
101296       {
101297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101298       };
101299     } catch (...) {
101300       {
101301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101302       };
101303     }
101304   }
101305 }
101306
101307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101308   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101309   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101310   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101311
101312   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101313   arg2 = (Dali::SlotObserver *)jarg2;
101314   arg3 = (Dali::CallbackBase *)jarg3;
101315   {
101316     try {
101317       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101318     } catch (std::out_of_range& e) {
101319       {
101320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101321       };
101322     } catch (std::exception& e) {
101323       {
101324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101325       };
101326     } catch (...) {
101327       {
101328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101329       };
101330     }
101331   }
101332 }
101333
101334
101335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101336   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101337   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101338   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101339
101340   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101341   arg2 = (Dali::SlotObserver *)jarg2;
101342   arg3 = (Dali::CallbackBase *)jarg3;
101343   {
101344     try {
101345       (arg1)->SignalDisconnected(arg2,arg3);
101346     } catch (std::out_of_range& e) {
101347       {
101348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101349       };
101350     } catch (std::exception& e) {
101351       {
101352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101353       };
101354     } catch (...) {
101355       {
101356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101357       };
101358     }
101359   }
101360 }
101361
101362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101363   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101364   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101365   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101366
101367   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101368   arg2 = (Dali::SlotObserver *)jarg2;
101369   arg3 = (Dali::CallbackBase *)jarg3;
101370   {
101371     try {
101372       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101373     } catch (std::out_of_range& e) {
101374       {
101375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101376       };
101377     } catch (std::exception& e) {
101378       {
101379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101380       };
101381     } catch (...) {
101382       {
101383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101384       };
101385     }
101386   }
101387 }
101388
101389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101390   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101391   std::string *arg2 = 0 ;
101392
101393   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101394   if (!jarg2) {
101395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101396     return ;
101397   }
101398   std::string arg2_str(jarg2);
101399   arg2 = &arg2_str;
101400   {
101401     try {
101402       (arg1)->SetContentInfo((std::string const &)*arg2);
101403     } catch (std::out_of_range& e) {
101404       {
101405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101406       };
101407     } catch (std::exception& e) {
101408       {
101409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101410       };
101411     } catch (...) {
101412       {
101413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101414       };
101415     }
101416   }
101417 }
101418
101419
101420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101421   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101422   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101423
101424   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101425   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101426   {
101427     try {
101428       (arg1)->SetImpl(arg2);
101429     } catch (std::out_of_range& e) {
101430       {
101431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101432       };
101433     } catch (std::exception& e) {
101434       {
101435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101436       };
101437     } catch (...) {
101438       {
101439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101440       };
101441     }
101442   }
101443 }
101444
101445 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) {
101446
101447   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101448   if (director) {
101449     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101450   }
101451 }
101452
101453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101454   void * jresult ;
101455   Dali::Widget *arg1 = 0 ;
101456   SwigDirector_WidgetImpl *result = 0 ;
101457
101458   arg1 = (Dali::Widget *)jarg1;
101459   if (!arg1) {
101460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101461     return 0;
101462   }
101463   {
101464     try {
101465       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101466     } catch (std::out_of_range& e) {
101467       {
101468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101469       };
101470     } catch (std::exception& e) {
101471       {
101472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101473       };
101474     } catch (...) {
101475       {
101476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101477       };
101478     }
101479   }
101480
101481   jresult = (void *)result;
101482   return jresult;
101483 }
101484
101485
101486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101487   void * jresult ;
101488   int *arg1 = (int *) 0 ;
101489   char ***arg2 ;
101490   std::string *arg3 = 0 ;
101491   Dali::WidgetApplication result;
101492   {
101493     int index = 0;
101494     int length = 0;
101495     char *retPtr;
101496     char *nextPtr;
101497     argWidgetC = jarg1;
101498     argWidgetV = new char*[jarg1 + 1];
101499
101500     retPtr = strtok_r( jarg2, " ", &nextPtr);
101501     if( retPtr )
101502     {
101503       length = strlen(retPtr);
101504     }
101505     argWidgetV[index] = new char[length + 1];
101506     if( retPtr )
101507     {
101508       strncpy(argWidgetV[index], retPtr, length);
101509     }
101510     argWidgetV[index][length] = '\0';
101511     index++;
101512
101513     while (index < jarg1)
101514     {
101515       length = 0;
101516       retPtr = strtok_r(NULL, " ", &nextPtr);
101517       if( retPtr )
101518       {
101519         length = strlen(retPtr);
101520       }
101521       argWidgetV[index] = new char[length + 1];
101522       if( retPtr )
101523       {
101524         strncpy(argWidgetV[index], retPtr, length);
101525       }
101526       argWidgetV[index][length] = '\0';
101527       index++;
101528     }
101529
101530     argWidgetV[jarg1] = NULL;
101531     argWidgetC = jarg1;
101532
101533     arg1 = &argWidgetC;
101534     arg2 = &argWidgetV;
101535   }
101536
101537   if (!jarg3) {
101538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101539     return 0;
101540   }
101541   std::string arg3_str(jarg3);
101542   arg3 = &arg3_str;
101543   {
101544     try {
101545       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101546     } catch (std::out_of_range& e) {
101547       {
101548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101549       };
101550     } catch (std::exception& e) {
101551       {
101552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101553       };
101554     } catch (...) {
101555       {
101556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101557       };
101558     }
101559   }
101560   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101561
101562   return jresult;
101563 }
101564
101565
101566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101567   void * jresult ;
101568   Dali::WidgetApplication *result = 0 ;
101569
101570   {
101571     try {
101572       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101573     } catch (std::out_of_range& e) {
101574       {
101575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101576       };
101577     } catch (std::exception& e) {
101578       {
101579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101580       };
101581     } catch (...) {
101582       {
101583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101584       };
101585     }
101586   }
101587   jresult = (void *)result;
101588   return jresult;
101589 }
101590
101591
101592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101593   void * jresult ;
101594   Dali::WidgetApplication *arg1 = 0 ;
101595   Dali::WidgetApplication *result = 0 ;
101596
101597   arg1 = (Dali::WidgetApplication *)jarg1;
101598   if (!arg1) {
101599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101600     return 0;
101601   }
101602   {
101603     try {
101604       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101605     } catch (std::out_of_range& e) {
101606       {
101607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101608       };
101609     } catch (std::exception& e) {
101610       {
101611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101612       };
101613     } catch (...) {
101614       {
101615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101616       };
101617     }
101618   }
101619   jresult = (void *)result;
101620   return jresult;
101621 }
101622
101623
101624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101625   void * jresult ;
101626   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101627   Dali::WidgetApplication *arg2 = 0 ;
101628   Dali::WidgetApplication *result = 0 ;
101629
101630   arg1 = (Dali::WidgetApplication *)jarg1;
101631   arg2 = (Dali::WidgetApplication *)jarg2;
101632   if (!arg2) {
101633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101634     return 0;
101635   }
101636   {
101637     try {
101638       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101639     } catch (std::out_of_range& e) {
101640       {
101641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101642       };
101643     } catch (std::exception& e) {
101644       {
101645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101646       };
101647     } catch (...) {
101648       {
101649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101650       };
101651     }
101652   }
101653   jresult = (void *)result;
101654   return jresult;
101655 }
101656
101657
101658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101659   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101660
101661   arg1 = (Dali::WidgetApplication *)jarg1;
101662   {
101663     try {
101664       delete arg1;
101665       if( argWidgetV )
101666       {
101667         // free string data
101668         for( int i=0; i < argWidgetC+1; i++)
101669         {
101670           delete [] argWidgetV[i];
101671         }
101672         delete [] argWidgetV;
101673       }
101674     } catch (std::out_of_range& e) {
101675       {
101676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101677       };
101678     } catch (std::exception& e) {
101679       {
101680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101681       };
101682     } catch (...) {
101683       {
101684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101685       };
101686     }
101687   }
101688 }
101689
101690
101691 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101692 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101693
101694 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101695 {
101696   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101697   return *widget;
101698 }
101699
101700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101701   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101702   std::string *arg2 = 0 ;
101703
101704   arg1 = (Dali::WidgetApplication *)jarg1;
101705   if (!jarg2) {
101706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101707     return ;
101708   }
101709   std::string arg2_str(*jarg2);
101710   arg2 = &arg2_str;
101711
101712   if(!_CSharpCreateWidgetFunction)
101713   {
101714     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101715   }
101716
101717   {
101718     try {
101719       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101720     } catch (std::out_of_range& e) {
101721       {
101722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101723       };
101724     } catch (std::exception& e) {
101725       {
101726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101727       };
101728     } catch (...) {
101729       {
101730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101731       };
101732     }
101733   }
101734
101735   //Typemap argout in c++ file.
101736   //This will convert c++ string to c# string
101737   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101738 }
101739
101740
101741 //for PixelBuffer and ImageLoading
101742
101743 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101744     return (Dali::BaseHandle *)jarg1;
101745 }
101746
101747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101748   void * jresult ;
101749   unsigned int arg1 ;
101750   unsigned int arg2 ;
101751   Dali::Pixel::Format arg3 ;
101752   Dali::Devel::PixelBuffer result;
101753
101754   arg1 = (unsigned int)jarg1;
101755   arg2 = (unsigned int)jarg2;
101756   arg3 = (Dali::Pixel::Format)jarg3;
101757   {
101758     try {
101759       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101760     } catch (std::out_of_range& e) {
101761       {
101762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101763       };
101764     } catch (std::exception& e) {
101765       {
101766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101767       };
101768     } catch (...) {
101769       {
101770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101771       };
101772     }
101773   }
101774   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101775   return jresult;
101776 }
101777
101778
101779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101780   void * jresult ;
101781   Dali::Devel::PixelBuffer *result = 0 ;
101782
101783   {
101784     try {
101785       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101786     } catch (std::out_of_range& e) {
101787       {
101788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101789       };
101790     } catch (std::exception& e) {
101791       {
101792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101793       };
101794     } catch (...) {
101795       {
101796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101797       };
101798     }
101799   }
101800   jresult = (void *)result;
101801   return jresult;
101802 }
101803
101804
101805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101806   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101807
101808   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101809   {
101810     try {
101811       delete arg1;
101812     } catch (std::out_of_range& e) {
101813       {
101814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101815       };
101816     } catch (std::exception& e) {
101817       {
101818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101819       };
101820     } catch (...) {
101821       {
101822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101823       };
101824     }
101825   }
101826 }
101827
101828
101829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101830   void * jresult ;
101831   Dali::Devel::PixelBuffer *arg1 = 0 ;
101832   Dali::Devel::PixelBuffer *result = 0 ;
101833
101834   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101835   if (!arg1) {
101836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101837     return 0;
101838   }
101839   {
101840     try {
101841       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101842     } catch (std::out_of_range& e) {
101843       {
101844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101845       };
101846     } catch (std::exception& e) {
101847       {
101848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101849       };
101850     } catch (...) {
101851       {
101852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101853       };
101854     }
101855   }
101856   jresult = (void *)result;
101857   return jresult;
101858 }
101859
101860
101861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101862   void * jresult ;
101863   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101864   Dali::Devel::PixelBuffer *arg2 = 0 ;
101865   Dali::Devel::PixelBuffer *result = 0 ;
101866
101867   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101868   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101869   if (!arg2) {
101870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101871     return 0;
101872   }
101873   {
101874     try {
101875       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101876     } catch (std::out_of_range& e) {
101877       {
101878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101879       };
101880     } catch (std::exception& e) {
101881       {
101882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101883       };
101884     } catch (...) {
101885       {
101886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101887       };
101888     }
101889   }
101890   jresult = (void *)result;
101891   return jresult;
101892 }
101893
101894
101895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101896   void * jresult ;
101897   Dali::Devel::PixelBuffer *arg1 = 0 ;
101898   Dali::PixelData result;
101899
101900   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101901   if (!arg1) {
101902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101903     return 0;
101904   }
101905   {
101906     try {
101907       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101908     } catch (std::out_of_range& e) {
101909       {
101910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101911       };
101912     } catch (std::exception& e) {
101913       {
101914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101915       };
101916     } catch (...) {
101917       {
101918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101919       };
101920     }
101921   }
101922   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101923   return jresult;
101924 }
101925
101926
101927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101928   void * jresult ;
101929   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101930   Dali::PixelData result;
101931
101932   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101933   {
101934     try {
101935       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101936     } catch (std::out_of_range& e) {
101937       {
101938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101939       };
101940     } catch (std::exception& e) {
101941       {
101942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101943       };
101944     } catch (...) {
101945       {
101946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101947       };
101948     }
101949   }
101950   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101951   return jresult;
101952 }
101953
101954
101955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101956   void * jresult ;
101957   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101958   unsigned char *result = 0 ;
101959
101960   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101961   {
101962     try {
101963       result = (unsigned char *)(arg1)->GetBuffer();
101964     } catch (std::out_of_range& e) {
101965       {
101966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101967       };
101968     } catch (std::exception& e) {
101969       {
101970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101971       };
101972     } catch (...) {
101973       {
101974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101975       };
101976     }
101977   }
101978   jresult = (void *)result;
101979   return jresult;
101980 }
101981
101982
101983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101984   unsigned int jresult ;
101985   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101986   unsigned int result;
101987
101988   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101989   {
101990     try {
101991       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101992     } catch (std::out_of_range& e) {
101993       {
101994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101995       };
101996     } catch (std::exception& e) {
101997       {
101998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101999       };
102000     } catch (...) {
102001       {
102002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102003       };
102004     }
102005   }
102006   jresult = result;
102007   return jresult;
102008 }
102009
102010
102011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102012   unsigned int jresult ;
102013   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102014   unsigned int result;
102015
102016   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102017   {
102018     try {
102019       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102020     } catch (std::out_of_range& e) {
102021       {
102022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102023       };
102024     } catch (std::exception& e) {
102025       {
102026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102027       };
102028     } catch (...) {
102029       {
102030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102031       };
102032     }
102033   }
102034   jresult = result;
102035   return jresult;
102036 }
102037
102038
102039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102040   int jresult ;
102041   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102042   Dali::Pixel::Format result;
102043
102044   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102045   {
102046     try {
102047       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102048     } catch (std::out_of_range& e) {
102049       {
102050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102051       };
102052     } catch (std::exception& e) {
102053       {
102054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102055       };
102056     } catch (...) {
102057       {
102058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102059       };
102060     }
102061   }
102062   jresult = (int)result;
102063   return jresult;
102064 }
102065
102066
102067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102068   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102069   Dali::Devel::PixelBuffer arg2 ;
102070   float arg3 ;
102071   bool arg4 ;
102072   Dali::Devel::PixelBuffer *argp2 ;
102073
102074   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102075   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102076   if (!argp2) {
102077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102078     return ;
102079   }
102080   arg2 = *argp2;
102081   arg3 = (float)jarg3;
102082   arg4 = jarg4 ? true : false;
102083   {
102084     try {
102085       (arg1)->ApplyMask(arg2,arg3,arg4);
102086     } catch (std::out_of_range& e) {
102087       {
102088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102089       };
102090     } catch (std::exception& e) {
102091       {
102092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102093       };
102094     } catch (...) {
102095       {
102096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102097       };
102098     }
102099   }
102100 }
102101
102102
102103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102104   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102105   Dali::Devel::PixelBuffer arg2 ;
102106   float arg3 ;
102107   Dali::Devel::PixelBuffer *argp2 ;
102108
102109   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102110   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102111   if (!argp2) {
102112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102113     return ;
102114   }
102115   arg2 = *argp2;
102116   arg3 = (float)jarg3;
102117   {
102118     try {
102119       (arg1)->ApplyMask(arg2,arg3);
102120     } catch (std::out_of_range& e) {
102121       {
102122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102123       };
102124     } catch (std::exception& e) {
102125       {
102126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102127       };
102128     } catch (...) {
102129       {
102130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102131       };
102132     }
102133   }
102134 }
102135
102136
102137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102138   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102139   Dali::Devel::PixelBuffer arg2 ;
102140   Dali::Devel::PixelBuffer *argp2 ;
102141
102142   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102143   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102144   if (!argp2) {
102145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102146     return ;
102147   }
102148   arg2 = *argp2;
102149   {
102150     try {
102151       (arg1)->ApplyMask(arg2);
102152     } catch (std::out_of_range& e) {
102153       {
102154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102155       };
102156     } catch (std::exception& e) {
102157       {
102158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102159       };
102160     } catch (...) {
102161       {
102162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102163       };
102164     }
102165   }
102166 }
102167
102168
102169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102170   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102171   float arg2 ;
102172
102173   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102174   arg2 = (float)jarg2;
102175   {
102176     try {
102177       (arg1)->ApplyGaussianBlur(arg2);
102178     } catch (std::out_of_range& e) {
102179       {
102180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102181       };
102182     } catch (std::exception& e) {
102183       {
102184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102185       };
102186     } catch (...) {
102187       {
102188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102189       };
102190     }
102191   }
102192 }
102193
102194
102195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102196   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102197   uint16_t arg2 ;
102198   uint16_t arg3 ;
102199   uint16_t arg4 ;
102200   uint16_t arg5 ;
102201
102202   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102203   arg2 = (uint16_t)jarg2;
102204   arg3 = (uint16_t)jarg3;
102205   arg4 = (uint16_t)jarg4;
102206   arg5 = (uint16_t)jarg5;
102207   {
102208     try {
102209       (arg1)->Crop(arg2,arg3,arg4,arg5);
102210     } catch (std::out_of_range& e) {
102211       {
102212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102213       };
102214     } catch (std::exception& e) {
102215       {
102216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102217       };
102218     } catch (...) {
102219       {
102220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102221       };
102222     }
102223   }
102224 }
102225
102226
102227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102228   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102229   uint16_t arg2 ;
102230   uint16_t arg3 ;
102231
102232   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102233   arg2 = (uint16_t)jarg2;
102234   arg3 = (uint16_t)jarg3;
102235   {
102236     try {
102237       (arg1)->Resize(arg2,arg3);
102238     } catch (std::out_of_range& e) {
102239       {
102240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102241       };
102242     } catch (std::exception& e) {
102243       {
102244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102245       };
102246     } catch (...) {
102247       {
102248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102249       };
102250     }
102251   }
102252 }
102253
102254
102255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102256   void * jresult ;
102257   std::string *arg1 = 0 ;
102258   Dali::ImageDimensions arg2 ;
102259   Dali::FittingMode::Type arg3 ;
102260   Dali::SamplingMode::Type arg4 ;
102261   bool arg5 ;
102262   Dali::ImageDimensions *argp2 ;
102263   Dali::Devel::PixelBuffer result;
102264
102265   if (!jarg1) {
102266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102267     return 0;
102268   }
102269   std::string arg1_str(jarg1);
102270   arg1 = &arg1_str;
102271   argp2 = (Dali::ImageDimensions *)jarg2;
102272   if (!argp2) {
102273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102274     return 0;
102275   }
102276   arg2 = *argp2;
102277   arg3 = (Dali::FittingMode::Type)jarg3;
102278   arg4 = (Dali::SamplingMode::Type)jarg4;
102279   arg5 = jarg5 ? true : false;
102280   {
102281     try {
102282       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102283     } catch (std::out_of_range& e) {
102284       {
102285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102286       };
102287     } catch (std::exception& e) {
102288       {
102289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102290       };
102291     } catch (...) {
102292       {
102293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102294       };
102295     }
102296   }
102297   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102298
102299   return jresult;
102300 }
102301
102302
102303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102304   void * jresult ;
102305   std::string *arg1 = 0 ;
102306   Dali::ImageDimensions arg2 ;
102307   Dali::FittingMode::Type arg3 ;
102308   Dali::SamplingMode::Type arg4 ;
102309   Dali::ImageDimensions *argp2 ;
102310   Dali::Devel::PixelBuffer result;
102311
102312   if (!jarg1) {
102313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102314     return 0;
102315   }
102316   std::string arg1_str(jarg1);
102317   arg1 = &arg1_str;
102318   argp2 = (Dali::ImageDimensions *)jarg2;
102319   if (!argp2) {
102320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102321     return 0;
102322   }
102323   arg2 = *argp2;
102324   arg3 = (Dali::FittingMode::Type)jarg3;
102325   arg4 = (Dali::SamplingMode::Type)jarg4;
102326   {
102327     try {
102328       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102329     } catch (std::out_of_range& e) {
102330       {
102331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102332       };
102333     } catch (std::exception& e) {
102334       {
102335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102336       };
102337     } catch (...) {
102338       {
102339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102340       };
102341     }
102342   }
102343   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102344
102345   return jresult;
102346 }
102347
102348
102349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102350   void * jresult ;
102351   std::string *arg1 = 0 ;
102352   Dali::ImageDimensions arg2 ;
102353   Dali::FittingMode::Type arg3 ;
102354   Dali::ImageDimensions *argp2 ;
102355   Dali::Devel::PixelBuffer result;
102356
102357   if (!jarg1) {
102358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102359     return 0;
102360   }
102361   std::string arg1_str(jarg1);
102362   arg1 = &arg1_str;
102363   argp2 = (Dali::ImageDimensions *)jarg2;
102364   if (!argp2) {
102365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102366     return 0;
102367   }
102368   arg2 = *argp2;
102369   arg3 = (Dali::FittingMode::Type)jarg3;
102370   {
102371     try {
102372       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102373     } catch (std::out_of_range& e) {
102374       {
102375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102376       };
102377     } catch (std::exception& e) {
102378       {
102379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102380       };
102381     } catch (...) {
102382       {
102383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102384       };
102385     }
102386   }
102387   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102388
102389   return jresult;
102390 }
102391
102392
102393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102394   void * jresult ;
102395   std::string *arg1 = 0 ;
102396   Dali::ImageDimensions arg2 ;
102397   Dali::ImageDimensions *argp2 ;
102398   Dali::Devel::PixelBuffer result;
102399
102400   if (!jarg1) {
102401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102402     return 0;
102403   }
102404   std::string arg1_str(jarg1);
102405   arg1 = &arg1_str;
102406   argp2 = (Dali::ImageDimensions *)jarg2;
102407   if (!argp2) {
102408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102409     return 0;
102410   }
102411   arg2 = *argp2;
102412   {
102413     try {
102414       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102415     } catch (std::out_of_range& e) {
102416       {
102417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102418       };
102419     } catch (std::exception& e) {
102420       {
102421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102422       };
102423     } catch (...) {
102424       {
102425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102426       };
102427     }
102428   }
102429   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102430
102431   return jresult;
102432 }
102433
102434
102435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102436   void * jresult ;
102437   std::string *arg1 = 0 ;
102438   Dali::Devel::PixelBuffer result;
102439
102440   if (!jarg1) {
102441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102442     return 0;
102443   }
102444   std::string arg1_str(jarg1);
102445   arg1 = &arg1_str;
102446   {
102447     try {
102448       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102449     } catch (std::out_of_range& e) {
102450       {
102451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102452       };
102453     } catch (std::exception& e) {
102454       {
102455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102456       };
102457     } catch (...) {
102458       {
102459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102460       };
102461     }
102462   }
102463   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102464
102465   return jresult;
102466 }
102467
102468
102469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102470   void * jresult ;
102471   std::string *arg1 = 0 ;
102472   Dali::ImageDimensions arg2 ;
102473   Dali::FittingMode::Type arg3 ;
102474   Dali::SamplingMode::Type arg4 ;
102475   bool arg5 ;
102476   Dali::ImageDimensions *argp2 ;
102477   Dali::ImageDimensions result;
102478
102479   if (!jarg1) {
102480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102481     return 0;
102482   }
102483   std::string arg1_str(jarg1);
102484   arg1 = &arg1_str;
102485   argp2 = (Dali::ImageDimensions *)jarg2;
102486   if (!argp2) {
102487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102488     return 0;
102489   }
102490   arg2 = *argp2;
102491   arg3 = (Dali::FittingMode::Type)jarg3;
102492   arg4 = (Dali::SamplingMode::Type)jarg4;
102493   arg5 = jarg5 ? true : false;
102494   {
102495     try {
102496       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102497     } catch (std::out_of_range& e) {
102498       {
102499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102500       };
102501     } catch (std::exception& e) {
102502       {
102503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102504       };
102505     } catch (...) {
102506       {
102507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102508       };
102509     }
102510   }
102511   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102512
102513   return jresult;
102514 }
102515
102516
102517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102518   void * jresult ;
102519   std::string *arg1 = 0 ;
102520   Dali::ImageDimensions arg2 ;
102521   Dali::FittingMode::Type arg3 ;
102522   Dali::SamplingMode::Type arg4 ;
102523   Dali::ImageDimensions *argp2 ;
102524   Dali::ImageDimensions result;
102525
102526   if (!jarg1) {
102527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102528     return 0;
102529   }
102530   std::string arg1_str(jarg1);
102531   arg1 = &arg1_str;
102532   argp2 = (Dali::ImageDimensions *)jarg2;
102533   if (!argp2) {
102534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102535     return 0;
102536   }
102537   arg2 = *argp2;
102538   arg3 = (Dali::FittingMode::Type)jarg3;
102539   arg4 = (Dali::SamplingMode::Type)jarg4;
102540   {
102541     try {
102542       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102543     } catch (std::out_of_range& e) {
102544       {
102545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102546       };
102547     } catch (std::exception& e) {
102548       {
102549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102550       };
102551     } catch (...) {
102552       {
102553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102554       };
102555     }
102556   }
102557   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102558
102559   return jresult;
102560 }
102561
102562
102563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102564   void * jresult ;
102565   std::string *arg1 = 0 ;
102566   Dali::ImageDimensions arg2 ;
102567   Dali::FittingMode::Type arg3 ;
102568   Dali::ImageDimensions *argp2 ;
102569   Dali::ImageDimensions result;
102570
102571   if (!jarg1) {
102572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102573     return 0;
102574   }
102575   std::string arg1_str(jarg1);
102576   arg1 = &arg1_str;
102577   argp2 = (Dali::ImageDimensions *)jarg2;
102578   if (!argp2) {
102579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102580     return 0;
102581   }
102582   arg2 = *argp2;
102583   arg3 = (Dali::FittingMode::Type)jarg3;
102584   {
102585     try {
102586       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102587     } catch (std::out_of_range& e) {
102588       {
102589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102590       };
102591     } catch (std::exception& e) {
102592       {
102593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102594       };
102595     } catch (...) {
102596       {
102597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102598       };
102599     }
102600   }
102601   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102602
102603   return jresult;
102604 }
102605
102606
102607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102608   void * jresult ;
102609   std::string *arg1 = 0 ;
102610   Dali::ImageDimensions arg2 ;
102611   Dali::ImageDimensions *argp2 ;
102612   Dali::ImageDimensions result;
102613
102614   if (!jarg1) {
102615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102616     return 0;
102617   }
102618   std::string arg1_str(jarg1);
102619   arg1 = &arg1_str;
102620   argp2 = (Dali::ImageDimensions *)jarg2;
102621   if (!argp2) {
102622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102623     return 0;
102624   }
102625   arg2 = *argp2;
102626   {
102627     try {
102628       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102629     } catch (std::out_of_range& e) {
102630       {
102631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102632       };
102633     } catch (std::exception& e) {
102634       {
102635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102636       };
102637     } catch (...) {
102638       {
102639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102640       };
102641     }
102642   }
102643   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102644
102645   return jresult;
102646 }
102647
102648
102649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102650   void * jresult ;
102651   std::string *arg1 = 0 ;
102652   Dali::ImageDimensions result;
102653
102654   if (!jarg1) {
102655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102656     return 0;
102657   }
102658   std::string arg1_str(jarg1);
102659   arg1 = &arg1_str;
102660   {
102661     try {
102662       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102663     } catch (std::out_of_range& e) {
102664       {
102665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102666       };
102667     } catch (std::exception& e) {
102668       {
102669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102670       };
102671     } catch (...) {
102672       {
102673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102674       };
102675     }
102676   }
102677   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102678
102679   return jresult;
102680 }
102681
102682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102683   void * jresult ;
102684   std::string *arg1 = 0 ;
102685   Dali::ImageDimensions result;
102686
102687   if (!jarg1) {
102688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102689     return 0;
102690   }
102691   std::string arg1_str(jarg1);
102692   arg1 = &arg1_str;
102693   {
102694     try {
102695       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
102696     } catch (std::out_of_range& e) {
102697       {
102698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102699       };
102700     } catch (std::exception& e) {
102701       {
102702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102703       };
102704     } catch (...) {
102705       {
102706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102707       };
102708     }
102709   }
102710   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102711
102712   return jresult;
102713 }
102714
102715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102716   void * jresult ;
102717   std::string *arg1 = 0 ;
102718   Dali::ImageDimensions arg2 ;
102719   Dali::FittingMode::Type arg3 ;
102720   Dali::SamplingMode::Type arg4 ;
102721   bool arg5 ;
102722   Dali::ImageDimensions *argp2 ;
102723   Dali::Devel::PixelBuffer result;
102724
102725   if (!jarg1) {
102726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102727     return 0;
102728   }
102729   std::string arg1_str(jarg1);
102730   arg1 = &arg1_str;
102731   argp2 = (Dali::ImageDimensions *)jarg2;
102732   if (!argp2) {
102733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102734     return 0;
102735   }
102736   arg2 = *argp2;
102737   arg3 = (Dali::FittingMode::Type)jarg3;
102738   arg4 = (Dali::SamplingMode::Type)jarg4;
102739   arg5 = jarg5 ? true : false;
102740   {
102741     try {
102742       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102743     } catch (std::out_of_range& e) {
102744       {
102745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102746       };
102747     } catch (std::exception& e) {
102748       {
102749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102750       };
102751     } catch (...) {
102752       {
102753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102754       };
102755     }
102756   }
102757   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102758
102759   return jresult;
102760 }
102761
102762
102763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102764   void * jresult ;
102765   std::string *arg1 = 0 ;
102766   Dali::ImageDimensions arg2 ;
102767   Dali::FittingMode::Type arg3 ;
102768   Dali::SamplingMode::Type arg4 ;
102769   Dali::ImageDimensions *argp2 ;
102770   Dali::Devel::PixelBuffer result;
102771
102772   if (!jarg1) {
102773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102774     return 0;
102775   }
102776   std::string arg1_str(jarg1);
102777   arg1 = &arg1_str;
102778   argp2 = (Dali::ImageDimensions *)jarg2;
102779   if (!argp2) {
102780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102781     return 0;
102782   }
102783   arg2 = *argp2;
102784   arg3 = (Dali::FittingMode::Type)jarg3;
102785   arg4 = (Dali::SamplingMode::Type)jarg4;
102786   {
102787     try {
102788       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102789     } catch (std::out_of_range& e) {
102790       {
102791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102792       };
102793     } catch (std::exception& e) {
102794       {
102795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102796       };
102797     } catch (...) {
102798       {
102799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102800       };
102801     }
102802   }
102803   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102804
102805   return jresult;
102806 }
102807
102808
102809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102810   void * jresult ;
102811   std::string *arg1 = 0 ;
102812   Dali::ImageDimensions arg2 ;
102813   Dali::FittingMode::Type arg3 ;
102814   Dali::ImageDimensions *argp2 ;
102815   Dali::Devel::PixelBuffer result;
102816
102817   if (!jarg1) {
102818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102819     return 0;
102820   }
102821   std::string arg1_str(jarg1);
102822   arg1 = &arg1_str;
102823   argp2 = (Dali::ImageDimensions *)jarg2;
102824   if (!argp2) {
102825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102826     return 0;
102827   }
102828   arg2 = *argp2;
102829   arg3 = (Dali::FittingMode::Type)jarg3;
102830   {
102831     try {
102832       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102833     } catch (std::out_of_range& e) {
102834       {
102835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102836       };
102837     } catch (std::exception& e) {
102838       {
102839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102840       };
102841     } catch (...) {
102842       {
102843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102844       };
102845     }
102846   }
102847   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102848
102849   return jresult;
102850 }
102851
102852
102853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102854   void * jresult ;
102855   std::string *arg1 = 0 ;
102856   Dali::ImageDimensions arg2 ;
102857   Dali::ImageDimensions *argp2 ;
102858   Dali::Devel::PixelBuffer result;
102859
102860   if (!jarg1) {
102861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102862     return 0;
102863   }
102864   std::string arg1_str(jarg1);
102865   arg1 = &arg1_str;
102866   argp2 = (Dali::ImageDimensions *)jarg2;
102867   if (!argp2) {
102868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102869     return 0;
102870   }
102871   arg2 = *argp2;
102872   {
102873     try {
102874       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102875     } catch (std::out_of_range& e) {
102876       {
102877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102878       };
102879     } catch (std::exception& e) {
102880       {
102881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102882       };
102883     } catch (...) {
102884       {
102885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102886       };
102887     }
102888   }
102889   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102890
102891   return jresult;
102892 }
102893
102894
102895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102896   void * jresult ;
102897   std::string *arg1 = 0 ;
102898   Dali::Devel::PixelBuffer result;
102899
102900   if (!jarg1) {
102901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102902     return 0;
102903   }
102904   std::string arg1_str(jarg1);
102905   arg1 = &arg1_str;
102906   {
102907     try {
102908       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102909     } catch (std::out_of_range& e) {
102910       {
102911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102912       };
102913     } catch (std::exception& e) {
102914       {
102915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102916       };
102917     } catch (...) {
102918       {
102919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102920       };
102921     }
102922   }
102923   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102924
102925   return jresult;
102926 }
102927
102928
102929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102930   void * jresult ;
102931   Dali::Toolkit::WebView result;
102932
102933   {
102934     try {
102935       result = Dali::Toolkit::WebView::New();
102936     } catch (std::out_of_range& e) {
102937       {
102938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102939       };
102940     } catch (std::exception& e) {
102941       {
102942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102943       };
102944     } catch (Dali::DaliException e) {
102945       {
102946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102947       };
102948     } catch (...) {
102949       {
102950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102951       };
102952     }
102953   }
102954   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102955   return jresult;
102956 }
102957
102958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102959   void * jresult ;
102960   Dali::Toolkit::WebView result;
102961
102962   std::string *arg1;
102963   std::string *arg2;
102964
102965   if (!jarg1) {
102966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102967     return 0;
102968   }
102969   if (!jarg2) {
102970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102971     return 0;
102972   }
102973
102974   std::string jarg1_str = std::string(jarg1);
102975   std::string jarg2_str = std::string(jarg2);
102976
102977   arg1 = &jarg1_str;
102978   arg2 = &jarg2_str;
102979
102980   {
102981     try {
102982       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102983     } catch (std::out_of_range& e) {
102984       {
102985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102986       };
102987     } catch (std::exception& e) {
102988       {
102989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102990       };
102991     } catch (Dali::DaliException e) {
102992       {
102993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102994       };
102995     } catch (...) {
102996       {
102997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102998       };
102999     }
103000   }
103001   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103002   return jresult;
103003 }
103004
103005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103006   void * jresult ;
103007   Dali::Toolkit::WebView *arg1 = 0 ;
103008   Dali::Toolkit::WebView *result = 0 ;
103009
103010   arg1 = (Dali::Toolkit::WebView *)jarg1;
103011   if (!arg1) {
103012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103013     return 0;
103014   }
103015   {
103016     try {
103017       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103018     } catch (std::out_of_range& e) {
103019       {
103020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103021       };
103022     } catch (std::exception& e) {
103023       {
103024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103025       };
103026     } catch (Dali::DaliException e) {
103027       {
103028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103029       };
103030     } catch (...) {
103031       {
103032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103033       };
103034     }
103035   }
103036   jresult = (void *)result;
103037   return jresult;
103038 }
103039
103040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103041   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103042   arg1 = (Dali::Toolkit::WebView *)jarg1;
103043   {
103044     try {
103045       delete arg1;
103046     } catch (std::out_of_range& e) {
103047       {
103048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103049       };
103050     } catch (std::exception& e) {
103051       {
103052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103053       };
103054     } catch (Dali::DaliException e) {
103055       {
103056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103057       };
103058     } catch (...) {
103059       {
103060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103061       };
103062     }
103063   }
103064 }
103065
103066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103067   void * jresult ;
103068   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103069   Dali::Toolkit::WebView *arg2 = 0 ;
103070   Dali::Toolkit::WebView *result = 0 ;
103071
103072   arg1 = (Dali::Toolkit::WebView *)jarg1;
103073   arg2 = (Dali::Toolkit::WebView *)jarg2;
103074   if (!arg2) {
103075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103076     return 0;
103077   }
103078   {
103079     try {
103080       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103081     } catch (std::out_of_range& e) {
103082       {
103083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103084       };
103085     } catch (std::exception& e) {
103086       {
103087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103088       };
103089     } catch (Dali::DaliException e) {
103090       {
103091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103092       };
103093     } catch (...) {
103094       {
103095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103096       };
103097     }
103098   }
103099   jresult = (void *)result;
103100   return jresult;
103101 }
103102
103103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103104   void * jresult ;
103105   Dali::BaseHandle arg1 ;
103106   Dali::BaseHandle *argp1 ;
103107   Dali::Toolkit::WebView result;
103108
103109   argp1 = (Dali::BaseHandle *)jarg1;
103110   if (!argp1) {
103111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103112     return 0;
103113   }
103114   arg1 = *argp1;
103115   {
103116     try {
103117       result = Dali::Toolkit::WebView::DownCast(arg1);
103118     } catch (std::out_of_range& e) {
103119       {
103120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103121       };
103122     } catch (std::exception& e) {
103123       {
103124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103125       };
103126     } catch (Dali::DaliException e) {
103127       {
103128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103129       };
103130     } catch (...) {
103131       {
103132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103133       };
103134     }
103135   }
103136   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103137   return jresult;
103138 }
103139
103140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
103141   return (int) Dali::Toolkit::WebView::Property::URL;
103142 }
103143
103144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
103145   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
103146 }
103147
103148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
103149   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
103150 }
103151
103152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
103153   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
103154 }
103155
103156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
103157   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
103158 }
103159
103160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
103161   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
103162 }
103163
103164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
103165   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
103166 }
103167
103168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
103169   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
103170 }
103171
103172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103173   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103174   std::string *arg2;
103175
103176   arg1 = (Dali::Toolkit::WebView *)jarg1;
103177
103178   if (!jarg2) {
103179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103180     return;
103181   }
103182
103183   std::string jarg2str = std::string(jarg2);
103184   arg2 = &jarg2str;
103185   {
103186     try {
103187       (arg1)->LoadUrl((std::string const &)*arg2);
103188     } catch (std::out_of_range& e) {
103189       {
103190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103191       };
103192     } catch (std::exception& e) {
103193       {
103194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103195       };
103196     } catch (Dali::DaliException e) {
103197       {
103198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103199       };
103200     } catch (...) {
103201       {
103202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103203       };
103204     }
103205   }
103206 }
103207
103208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103209   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103210   std::string *arg2;
103211
103212   arg1 = (Dali::Toolkit::WebView *)jarg1;
103213   if (!jarg2) {
103214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103215     return;
103216   }
103217   std::string jarg2str = std::string(jarg2);
103218   arg2 = &jarg2str;
103219   {
103220     try {
103221       (arg1)->LoadHTMLString((std::string const &)*arg2);
103222     } catch (std::out_of_range& e) {
103223       {
103224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103225       };
103226     } catch (std::exception& e) {
103227       {
103228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103229       };
103230     } catch (Dali::DaliException e) {
103231       {
103232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103233       };
103234     } catch (...) {
103235       {
103236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103237       };
103238     }
103239   }
103240 }
103241
103242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103243   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103244
103245   arg1 = (Dali::Toolkit::WebView *)jarg1;
103246   {
103247     try {
103248       (arg1)->Reload();
103249     } catch (std::out_of_range& e) {
103250       {
103251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103252       };
103253     } catch (std::exception& e) {
103254       {
103255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103256       };
103257     } catch (Dali::DaliException e) {
103258       {
103259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103260       };
103261     } catch (...) {
103262       {
103263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103264       };
103265     }
103266   }
103267 }
103268
103269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103270   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103271
103272   arg1 = (Dali::Toolkit::WebView *)jarg1;
103273   {
103274     try {
103275       (arg1)->StopLoading();
103276     } catch (std::out_of_range& e) {
103277       {
103278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103279       };
103280     } catch (std::exception& e) {
103281       {
103282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103283       };
103284     } catch (Dali::DaliException e) {
103285       {
103286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103287       };
103288     } catch (...) {
103289       {
103290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103291       };
103292     }
103293   }
103294 }
103295
103296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
103297   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103298
103299   arg1 = (Dali::Toolkit::WebView *)jarg1;
103300   {
103301     try {
103302       (arg1)->Suspend();
103303     } catch (std::out_of_range& e) {
103304       {
103305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103306       };
103307     } catch (std::exception& e) {
103308       {
103309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103310       };
103311     } catch (Dali::DaliException e) {
103312       {
103313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103314       };
103315     } catch (...) {
103316       {
103317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103318       };
103319     }
103320   }
103321 }
103322
103323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
103324   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103325
103326   arg1 = (Dali::Toolkit::WebView *)jarg1;
103327   {
103328     try {
103329       (arg1)->Resume();
103330     } catch (std::out_of_range& e) {
103331       {
103332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103333       };
103334     } catch (std::exception& e) {
103335       {
103336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103337       };
103338     } catch (Dali::DaliException e) {
103339       {
103340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103341       };
103342     } catch (...) {
103343       {
103344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103345       };
103346     }
103347   }
103348 }
103349
103350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103351   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103352
103353   arg1 = (Dali::Toolkit::WebView *)jarg1;
103354   {
103355     try {
103356       (arg1)->GoBack();
103357     } catch (std::out_of_range& e) {
103358       {
103359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103360       };
103361     } catch (std::exception& e) {
103362       {
103363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103364       };
103365     } catch (Dali::DaliException e) {
103366       {
103367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103368       };
103369     } catch (...) {
103370       {
103371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103372       };
103373     }
103374   }
103375 }
103376
103377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103378   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103379
103380   arg1 = (Dali::Toolkit::WebView *)jarg1;
103381   {
103382     try {
103383       (arg1)->GoForward();
103384     } catch (std::out_of_range& e) {
103385       {
103386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103387       };
103388     } catch (std::exception& e) {
103389       {
103390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103391       };
103392     } catch (Dali::DaliException e) {
103393       {
103394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103395       };
103396     } catch (...) {
103397       {
103398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103399       };
103400     }
103401   }
103402 }
103403
103404 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103405   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103406   bool ret;
103407
103408   arg1 = (Dali::Toolkit::WebView *)jarg1;
103409   {
103410     try {
103411       ret = (arg1)->CanGoBack();
103412     } catch (std::out_of_range& e) {
103413       {
103414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103415       };
103416     } catch (std::exception& e) {
103417       {
103418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103419       };
103420     } catch (Dali::DaliException e) {
103421       {
103422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103423       };
103424     } catch (...) {
103425       {
103426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103427       };
103428     }
103429   }
103430   return ret;
103431 }
103432
103433 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103434   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103435   bool ret;
103436
103437   arg1 = (Dali::Toolkit::WebView *)jarg1;
103438   {
103439     try {
103440       ret = (arg1)->CanGoForward();
103441     } catch (std::out_of_range& e) {
103442       {
103443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103444       };
103445     } catch (std::exception& e) {
103446       {
103447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103448       };
103449     } catch (Dali::DaliException e) {
103450       {
103451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103452       };
103453     } catch (...) {
103454       {
103455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103456       };
103457     }
103458   }
103459   return ret;
103460 }
103461
103462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
103463   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103464   std::string *arg2;
103465
103466   arg1 = (Dali::Toolkit::WebView *)jarg1;
103467   if (!jarg2) {
103468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103469     return;
103470   }
103471   std::string jarg2_str = std::string(jarg2);
103472   arg2 = &jarg2_str;
103473
103474   {
103475     try {
103476       if (jarg3) {
103477         void (*handler)(char*) = (void (*)(char*)) jarg3;
103478         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
103479           handler(SWIG_csharp_string_callback(result.c_str()));
103480         });
103481       } else {
103482         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
103483       }
103484     } catch (std::out_of_range& e) {
103485       {
103486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103487       };
103488     } catch (std::exception& e) {
103489       {
103490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103491       };
103492     } catch (Dali::DaliException e) {
103493       {
103494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103495       };
103496     } catch (...) {
103497       {
103498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103499       };
103500     }
103501   }
103502 }
103503
103504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103505 {
103506   if (!jarg2) {
103507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103508     return;
103509   }
103510
103511   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103512   std::string exposedObjectName = jarg2;
103513   void (*handler)(char*) = (void (*)(char*)) jarg3;
103514
103515   {
103516     try {
103517       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103518         handler(SWIG_csharp_string_callback(message.c_str()));
103519       });
103520     } catch (std::out_of_range& e) {
103521       {
103522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103523       };
103524     } catch (std::exception& e) {
103525       {
103526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103527       };
103528     } catch (Dali::DaliException e) {
103529       {
103530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103531       };
103532     } catch (...) {
103533       {
103534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103535       };
103536     }
103537   }
103538 }
103539
103540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103541   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103542
103543   arg1 = (Dali::Toolkit::WebView *)jarg1;
103544   {
103545     try {
103546       (arg1)->ClearHistory();
103547     } catch (std::out_of_range& e) {
103548       {
103549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103550       };
103551     } catch (std::exception& e) {
103552       {
103553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103554       };
103555     } catch (Dali::DaliException e) {
103556       {
103557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103558       };
103559     } catch (...) {
103560       {
103561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103562       };
103563     }
103564   }
103565 }
103566
103567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103568   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103569
103570   arg1 = (Dali::Toolkit::WebView *)jarg1;
103571   {
103572     try {
103573       (arg1)->ClearCache();
103574     } catch (std::out_of_range& e) {
103575       {
103576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103577       };
103578     } catch (std::exception& e) {
103579       {
103580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103581       };
103582     } catch (Dali::DaliException e) {
103583       {
103584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103585       };
103586     } catch (...) {
103587       {
103588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103589       };
103590     }
103591   }
103592 }
103593
103594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
103595   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103596
103597   arg1 = (Dali::Toolkit::WebView *)jarg1;
103598   {
103599     try {
103600       (arg1)->ClearCookies();
103601     } catch (std::out_of_range& e) {
103602       {
103603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103604       };
103605     } catch (std::exception& e) {
103606       {
103607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103608       };
103609     } catch (Dali::DaliException e) {
103610       {
103611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103612       };
103613     } catch (...) {
103614       {
103615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103616       };
103617     }
103618   }
103619 }
103620
103621 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103622     return (Dali::Toolkit::Control *)jarg1;
103623 }
103624
103625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
103626   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103627   SignalConverter::WebViewPageLoadSignal* result = NULL;
103628   {
103629     try {
103630       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
103631     } catch (std::out_of_range& e) {
103632       {
103633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103634       };
103635     } catch (std::exception& e) {
103636       {
103637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103638       };
103639     } catch (Dali::DaliException e) {
103640       {
103641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103642       };
103643     } catch (...) {
103644       {
103645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103646       };
103647     }
103648   }
103649   return (void*) result;
103650 }
103651
103652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
103653   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103654   SignalConverter::WebViewPageLoadSignal* result = NULL;
103655   {
103656     try {
103657       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
103658     } catch (std::out_of_range& e) {
103659       {
103660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103661       };
103662     } catch (std::exception& e) {
103663       {
103664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103665       };
103666     } catch (Dali::DaliException e) {
103667       {
103668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103669       };
103670     } catch (...) {
103671       {
103672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103673       };
103674     }
103675   }
103676   return (void*) result;
103677 }
103678
103679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
103680 {
103681   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103682   {
103683     try {
103684       delete object;
103685     } catch (std::out_of_range& e) {
103686       {
103687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103688       };
103689     } catch (std::exception& e) {
103690       {
103691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103692       };
103693     } catch (Dali::DaliException e) {
103694       {
103695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103696       };
103697     } catch (...) {
103698       {
103699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103700       };
103701     }
103702   }
103703 }
103704
103705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
103706 {
103707   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103708   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103709   {
103710     try {
103711       proxy->Connect(callback);
103712     } catch (std::out_of_range& e) {
103713       {
103714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103715       };
103716     } catch (std::exception& e) {
103717       {
103718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103719       };
103720     } catch (Dali::DaliException e) {
103721       {
103722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103723       };
103724     } catch (...) {
103725       {
103726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103727       };
103728     }
103729   }
103730 }
103731
103732
103733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
103734   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103735   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103736   {
103737     try {
103738       proxy->Disconnect(callback);
103739     } catch (std::out_of_range& e) {
103740       {
103741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103742       };
103743     } catch (std::exception& e) {
103744       {
103745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103746       };
103747     } catch (Dali::DaliException e) {
103748       {
103749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103750       };
103751     } catch (...) {
103752       {
103753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103754       };
103755     }
103756   }
103757 }
103758
103759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
103760   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103761   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
103762   {
103763     try {
103764       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
103765     } catch (std::out_of_range& e) {
103766       {
103767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103768       };
103769     } catch (std::exception& e) {
103770       {
103771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103772       };
103773     } catch (Dali::DaliException e) {
103774       {
103775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103776       };
103777     } catch (...) {
103778       {
103779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103780       };
103781     }
103782   }
103783   return (void*) result;
103784 }
103785
103786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
103787 {
103788   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103789   {
103790     try {
103791       delete object;
103792     } catch (std::out_of_range& e) {
103793       {
103794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103795       };
103796     } catch (std::exception& e) {
103797       {
103798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103799       };
103800     } catch (Dali::DaliException e) {
103801       {
103802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103803       };
103804     } catch (...) {
103805       {
103806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103807       };
103808     }
103809   }
103810 }
103811
103812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
103813 {
103814   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103815   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103816   {
103817     try {
103818       proxy->Connect(callback);
103819     } catch (std::out_of_range& e) {
103820       {
103821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103822       };
103823     } catch (std::exception& e) {
103824       {
103825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103826       };
103827     } catch (Dali::DaliException e) {
103828       {
103829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103830       };
103831     } catch (...) {
103832       {
103833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103834       };
103835     }
103836   }
103837 }
103838
103839
103840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103841   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103842   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103843   {
103844     try {
103845       proxy->Disconnect(callback);
103846     } catch (std::out_of_range& e) {
103847       {
103848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103849       };
103850     } catch (std::exception& e) {
103851       {
103852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103853       };
103854     } catch (Dali::DaliException e) {
103855       {
103856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103857       };
103858     } catch (...) {
103859       {
103860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103861       };
103862     }
103863   }
103864 }
103865
103866 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103867   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103868   char * jresult = SWIG_csharp_string_callback((const char *)result);
103869   return jresult;
103870 }
103871
103872 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103873   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103874   return result;
103875 }
103876
103877 #ifdef __cplusplus
103878 }
103879 #endif
103880